types.h

Go to the documentation of this file.

/*
 * 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.
 */
 
#pragma once
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "iceberg/catalog/rest/endpoint.h"
#include "iceberg/catalog/rest/iceberg_rest_export.h"
#include "iceberg/result.h"
#include "iceberg/schema.h"
#include "iceberg/table_identifier.h"
#include "iceberg/type_fwd.h"
#include "iceberg/util/macros.h"
 
 
namespace iceberg::rest {
 
struct ICEBERG_REST_EXPORT CatalogConfig {
  std::unordered_map<std::string, std::string> defaults;   // required
  std::unordered_map<std::string, std::string> overrides;  // required
  std::vector<Endpoint> endpoints;
 
  Status Validate() const { return {}; }
 
  bool operator==(const CatalogConfig&) const = default;
};
 
struct ICEBERG_REST_EXPORT ErrorResponse {
  uint32_t code;        // required
  std::string type;     // required
  std::string message;  // required
  std::vector<std::string> stack;
 
  Status Validate() const {
    if (message.empty() || type.empty()) {
      return ValidationFailed("Invalid error response: missing required fields");
    }
 
    if (code < 400 || code > 600) {
      return ValidationFailed(
          "Invalid error response: code {} is out of range [400, 600]", code);
    }
 
    // stack is optional, no validation needed
    return {};
  }
 
  bool operator==(const ErrorResponse&) const = default;
};
 
struct ICEBERG_REST_EXPORT CreateNamespaceRequest {
  Namespace namespace_;  // required
  std::unordered_map<std::string, std::string> properties;
 
  Status Validate() const { return {}; }
 
  bool operator==(const CreateNamespaceRequest&) const = default;
};
 
struct ICEBERG_REST_EXPORT UpdateNamespacePropertiesRequest {
  std::vector<std::string> removals;
  std::unordered_map<std::string, std::string> updates;
 
  Status Validate() const {
    for (const auto& key : removals) {
      if (updates.contains(key)) {
        return ValidationFailed("Duplicate key to update and remove: {}", key);
      }
    }
    return {};
  }
 
  bool operator==(const UpdateNamespacePropertiesRequest&) const = default;
};
 
struct ICEBERG_REST_EXPORT RegisterTableRequest {
  std::string name;               // required
  std::string metadata_location;  // required
  bool overwrite = false;
 
  Status Validate() const {
    if (name.empty()) {
      return ValidationFailed("Missing table name");
    }
 
    if (metadata_location.empty()) {
      return ValidationFailed("Empty metadata location");
    }
 
    return {};
  }
 
  bool operator==(const RegisterTableRequest&) const = default;
};
 
struct ICEBERG_REST_EXPORT RenameTableRequest {
  TableIdentifier source;       // required
  TableIdentifier destination;  // required
 
  Status Validate() const {
    ICEBERG_RETURN_UNEXPECTED(source.Validate());
    ICEBERG_RETURN_UNEXPECTED(destination.Validate());
    return {};
  }
 
  bool operator==(const RenameTableRequest&) const = default;
};
 
struct ICEBERG_REST_EXPORT CreateTableRequest {
  std::string name;  // required
  std::string location;
  std::shared_ptr<Schema> schema;  // required
  std::shared_ptr<PartitionSpec> partition_spec;
  std::shared_ptr<SortOrder> write_order;
  bool stage_create = false;
  std::unordered_map<std::string, std::string> properties;
 
  Status Validate() const {
    if (name.empty()) {
      return ValidationFailed("Missing table name");
    }
    if (!schema) {
      return ValidationFailed("Missing schema");
    }
    return {};
  }
 
  bool operator==(const CreateTableRequest& other) const;
};
 
using PageToken = std::string;
 
struct ICEBERG_REST_EXPORT LoadTableResult {
  std::string metadata_location;
  std::shared_ptr<TableMetadata> metadata;  // required
  std::unordered_map<std::string, std::string> config;
  // TODO(Li Feiyang): Add std::shared_ptr<StorageCredential> storage_credential;
 
  Status Validate() const {
    if (!metadata) {
      return ValidationFailed("Invalid metadata: null");
    }
    return {};
  }
 
  bool operator==(const LoadTableResult& other) const;
};
 
using CreateTableResponse = LoadTableResult;
 
using LoadTableResponse = LoadTableResult;
 
struct ICEBERG_REST_EXPORT ListNamespacesResponse {
  PageToken next_page_token;
  std::vector<Namespace> namespaces;
 
  Status Validate() const { return {}; }
 
  bool operator==(const ListNamespacesResponse&) const = default;
};
 
struct ICEBERG_REST_EXPORT CreateNamespaceResponse {
  Namespace namespace_;  // required
  std::unordered_map<std::string, std::string> properties;
 
  Status Validate() const { return {}; }
 
  bool operator==(const CreateNamespaceResponse&) const = default;
};
 
struct ICEBERG_REST_EXPORT GetNamespaceResponse {
  Namespace namespace_;  // required
  std::unordered_map<std::string, std::string> properties;
 
  Status Validate() const { return {}; }
 
  bool operator==(const GetNamespaceResponse&) const = default;
};
 
struct ICEBERG_REST_EXPORT UpdateNamespacePropertiesResponse {
  std::vector<std::string> updated;  // required
  std::vector<std::string> removed;  // required
  std::vector<std::string> missing;
 
  Status Validate() const { return {}; }
 
  bool operator==(const UpdateNamespacePropertiesResponse&) const = default;
};
 
struct ICEBERG_REST_EXPORT ListTablesResponse {
  PageToken next_page_token;
  std::vector<TableIdentifier> identifiers;
 
  Status Validate() const { return {}; }
 
  bool operator==(const ListTablesResponse&) const = default;
};
 
struct ICEBERG_REST_EXPORT CommitTableRequest {
  TableIdentifier identifier;
  std::vector<std::shared_ptr<TableRequirement>> requirements;  // required
  std::vector<std::shared_ptr<TableUpdate>> updates;            // required
 
  Status Validate() const { return {}; }
 
  bool operator==(const CommitTableRequest& other) const;
};
 
struct ICEBERG_REST_EXPORT CommitTableResponse {
  std::string metadata_location;            // required
  std::shared_ptr<TableMetadata> metadata;  // required
 
  Status Validate() const {
    if (metadata_location.empty()) {
      return ValidationFailed("Invalid metadata location: empty");
    }
    if (!metadata) {
      return ValidationFailed("Invalid metadata: null");
    }
    return {};
  }
 
  bool operator==(const CommitTableResponse& other) const;
};
 
struct ICEBERG_REST_EXPORT OAuthTokenResponse {
  std::string access_token;                // required
  std::string token_type;                  // required, "bearer" or "N_A"
  std::optional<int64_t> expires_in_secs;  // optional, seconds until expiration
  std::string issued_token_type;           // optional, for token exchange
  std::string refresh_token;               // optional
  std::string scope;                       // optional
 
  Status Validate() const;
 
  bool operator==(const OAuthTokenResponse&) const = default;
};
 
}  // namespace iceberg::rest