ForeignDataWrapperFactory.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 "Catalog/TableDescriptor.h"
#include "ForeignDataWrapper.h"
#include "ImportExport/CopyParams.h"

namespace foreign_storage {
class UserMapping;

bool is_valid_source_type(const import_export::CopyParams& copy_params);

void validate_regex_parser_options(const import_export::CopyParams& copy_params);

std::tuple<std::unique_ptr<foreign_storage::ForeignServer>,
           std::unique_ptr<foreign_storage::UserMapping>,
           std::unique_ptr<foreign_storage::ForeignTable>>
create_proxy_fsi_objects(const std::string& copy_from_source,
                         const import_export::CopyParams& copy_params,
                         const int db_id,
                         const TableDescriptor* table,
                         const int32_t user_id);

std::tuple<std::unique_ptr<foreign_storage::ForeignServer>,
           std::unique_ptr<foreign_storage::UserMapping>,
           std::unique_ptr<foreign_storage::ForeignTable>>
create_proxy_fsi_objects(const std::string& copy_from_source,
                         const import_export::CopyParams& copy_params,
                         const TableDescriptor* table);

struct DataWrapperType {
  static constexpr char const* CSV = "DELIMITED_FILE";
  static constexpr char const* PARQUET = "PARQUET_FILE";
  static constexpr char const* REGEX_PARSER = "REGEX_PARSED_FILE";
  static constexpr char const* INTERNAL_CATALOG = "INTERNAL_CATALOG";
  static constexpr char const* INTERNAL_MEMORY_STATS = "INTERNAL_MEMORY_STATS";
  static constexpr char const* INTERNAL_STORAGE_STATS = "INTERNAL_STORAGE_STATS";
  static constexpr char const* INTERNAL_EXECUTOR_STATS = "INTERNAL_EXECUTOR_STATS";
  static constexpr char const* INTERNAL_ML_MODEL_METADATA = "INTERNAL_ML_MODEL_METADATA";
  static constexpr char const* INTERNAL_LOGS = "INTERNAL_LOGS";

  static constexpr std::array<char const*, 6> INTERNAL_DATA_WRAPPERS{
      INTERNAL_CATALOG,
      INTERNAL_MEMORY_STATS,
      INTERNAL_STORAGE_STATS,
      INTERNAL_EXECUTOR_STATS,
      INTERNAL_ML_MODEL_METADATA,
      INTERNAL_LOGS};

  static constexpr std::array<char const*, 5> IN_MEMORY_DATA_WRAPPERS{
      INTERNAL_CATALOG,
      INTERNAL_MEMORY_STATS,
      INTERNAL_STORAGE_STATS,
      INTERNAL_EXECUTOR_STATS,
      INTERNAL_ML_MODEL_METADATA};

  static constexpr std::array<std::string_view, 9> supported_data_wrapper_types{
      PARQUET,
      CSV,
      REGEX_PARSER,
      INTERNAL_CATALOG,
      INTERNAL_MEMORY_STATS,
      INTERNAL_STORAGE_STATS,
      INTERNAL_EXECUTOR_STATS,
      INTERNAL_ML_MODEL_METADATA,
      INTERNAL_LOGS};
};

class ForeignDataWrapperFactory {
 public:
  static std::unique_ptr<ForeignDataWrapper> create(const std::string& data_wrapper_type,
                                                    const int db_id,
                                                    const ForeignTable* foreign_table);

  static std::unique_ptr<UserMapping> createUserMappingProxyIfApplicable(
      const int db_id,
      const int user_id,
      const std::string& file_path,
      const import_export::CopyParams& copy_params,
      const ForeignServer* server);

  static std::unique_ptr<ForeignServer> createForeignServerProxy(
      const int db_id,
      const int user_id,
      const std::string& file_path,
      const import_export::CopyParams& copy_params);

  static std::unique_ptr<ForeignTable> createForeignTableProxy(
      const int db_id,
      const TableDescriptor* table,
      const std::string& file_path,
      const import_export::CopyParams& copy_params,
      const ForeignServer* server);

  static std::unique_ptr<ForeignDataWrapper> createForImport(
      const std::string& data_wrapper_type,
      const int db_id,
      const ForeignTable* foreign_table,
      const UserMapping* user_mapping);

  static std::unique_ptr<ForeignDataWrapper> createForGeneralImport(
      const import_export::CopyParams& copy_params,
      const int db_id,
      const ForeignTable* foreign_table,
      const UserMapping* user_mapping);

  static const ForeignDataWrapper* createForValidation(
      const std::string& data_wrapper_type,
      const ForeignTable* foreign_table = nullptr);

  static void validateDataWrapperType(const std::string& data_wrapper_type);

 private:
  static std::map<std::string, std::unique_ptr<ForeignDataWrapper>>
      validation_data_wrappers_;
};
}  // namespace foreign_storage