tables_clients.hpp

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
 
#pragma once
 
#include "azure/data/tables/credentials/azure_sas_credential.hpp"
#include "azure/data/tables/credentials/named_key_credential.hpp"
#include "azure/data/tables/models.hpp"
 
#include <azure/core/credentials/credentials.hpp>
#include <azure/core/http/http.hpp>
#include <azure/core/http/policies/policy.hpp>
#include <azure/core/internal/http/pipeline.hpp>
#include <azure/core/internal/json/json.hpp>
#include <azure/core/response.hpp>
 
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#ifdef _azure_TABLES_TESTING_BUILD
namespace Azure { namespace Data { namespace Tables { namespace StressTest {
  class TransactionStressTest;
}}}} // namespace Azure::Data::Tables::StressTest
namespace Azure { namespace Data { namespace Test {
  class TransactionsBodyTest_TransactionCreate_Test;
  class TransactionsBodyTest_TransactionBodyInsertMergeOp_Test;
  class TransactionsBodyTest_TransactionBodyInsertReplaceOp_Test;
  class TransactionsBodyTest_TransactionBodyDeleteOp_Test;
  class TransactionsBodyTest_TransactionBodyUpdateMergeOp_Test;
  class TransactionsBodyTest_TransactionBodyUpdateReplaceOp_Test;
  class TransactionsBodyTest_TransactionBodyAddOp_Test;
}}} // namespace Azure::Data::Test
#endif
 
namespace Azure { namespace Data { namespace Tables {
 
  namespace _detail {
    constexpr static const char* ApiVersion = "2019-02-02";
    constexpr static const char* TablesServicePackageName = "data-tables";
    // various strings used in the library
    constexpr static const char* OriginHeader = "Origin";
    constexpr static const char* AccessControlRequestMethodHeader = "Access-Control-Request-Method";
    constexpr static const char* ResrouceTypeService = "service";
    constexpr static const char* ComponentProperties = "properties";
    constexpr static const char* ContentTypeXml = "application/xml";
    constexpr static const char* ContentTypeJson = "application/json";
    constexpr static const char* ResourceTypeHeader = "restype";
    constexpr static const char* CompHeader = "comp";
    constexpr static const char* ContentTypeHeader = "Content-Type";
    constexpr static const char* ContentLengthHeader = "Content-Length";
    constexpr static const char* AcceptHeader = "Accept";
    constexpr static const char* PreferHeader = "Prefer";
    constexpr static const char* PreferNoContent = "return-no-content";
    constexpr static const char* AcceptFullMeta = "application/json;odata=fullmetadata";
    constexpr static const char* IfMatch = "If-Match";
    constexpr static const char* PartitionKeyFragment = "(PartitionKey='";
    constexpr static const char* RowKeyFragment = "',RowKey='";
    constexpr static const char* ClosingFragment = "')";
    constexpr static const char* Value = "value";
    constexpr static const char* TableName = "TableName";
    constexpr static const char* ODataEditLink = "odata.editLink";
    constexpr static const char* ODataId = "odata.id";
    constexpr static const char* ODataType = "odata.type";
    constexpr static const char* ODataMeta = "odata.metadata";
    constexpr static const char* ODataError = "odata.error";
  } // namespace _detail
 
  class ServiceVersion final {
  public:
    explicit ServiceVersion(std::string version) : m_version{std::move(version)} {}
 
    bool operator==(const ServiceVersion& other) const { return m_version == other.m_version; }
 
    bool operator!=(const ServiceVersion& other) const { return !(*this == other); }
 
    std::string const& ToString() const { return m_version; }
 
    AZ_DATA_TABLES_DLLEXPORT const static ServiceVersion V2019_02_02;
 
  private:
    std::string m_version;
  };
 
  class TablesAudience final
      : public Azure::Core::_internal::ExtendableEnumeration<TablesAudience> {
  public:
    explicit TablesAudience(std::string tablesAudience)
        : ExtendableEnumeration(std::move(tablesAudience))
    {
    }
  };
 
  struct TableClientOptions final : Azure::Core::_internal::ClientOptions
  {
    ServiceVersion ApiVersion{_detail::ApiVersion};
 
    bool EnableTenantDiscovery = false;
 
    Azure::Nullable<TablesAudience> Audience;
  };
 
  class TableClient final {
  public:
    explicit TableClient(
        std::string const& serviceUrl,
        std::string const& tableName,
        const TableClientOptions& options = {});
    explicit TableClient(
        const std::string& serviceUrl,
        const std::string& tableName,
        std::shared_ptr<Core::Credentials::TokenCredential> credential,
        const TableClientOptions& options = {});
 
    explicit TableClient(
        const std::string& tableName,
        std::shared_ptr<Azure::Data::Tables::Credentials::NamedKeyCredential> credential,
        std::string url,
        const TableClientOptions& options = {});
 
    explicit TableClient(
        const std::string& serviceUrl,
        std::shared_ptr<Azure::Data::Tables::Credentials::AzureSasCredential> credential,
        const std::string& tableName,
        const TableClientOptions& options = {});
 
    static TableClient CreateFromConnectionString(
        const std::string& connectionString,
        const std::string& tableName,
        const TableClientOptions& options = {});
 
    Response<Models::TableAccessPolicy> GetAccessPolicy(Core::Context const& context = {});
 
    Response<Models::SetTableAccessPolicyResult> SetAccessPolicy(
        Models::TableAccessPolicy const& tableAccessPolicy,
        Core::Context const& context = {});
 
    Response<Models::AddEntityResult> AddEntity(
        Models::TableEntity const& tableEntity,
        Models::AddEntityOptions const& options = {},
        Core::Context const& context = {});
 
    Response<Models::UpdateEntityResult> UpdateEntity(
        Models::TableEntity const& tableEntity,
        Models::UpdateEntityOptions const& options = {},
        Core::Context const& context = {});
 
    Response<Models::MergeEntityResult> MergeEntity(
        Models::TableEntity const& tableEntity,
        Models::MergeEntityOptions const& options = {},
        Core::Context const& context = {});
 
    Response<Models::DeleteEntityResult> DeleteEntity(
        Models::TableEntity const& tableEntity,
        Core::Context const& context = {});
 
    Response<Models::UpsertEntityResult> UpsertEntity(
        Models::TableEntity const& tableEntity,
        Models::UpsertEntityOptions const& options = {},
        Core::Context const& context = {});
 
    Models::QueryEntitiesPagedResponse QueryEntities(
        Models::QueryEntitiesOptions const& options = {},
        Core::Context const& context = {});
 
    Response<Models::TableEntity> GetEntity(
        const std::string& partitionKey,
        const std::string& rowKey,
        Core::Context const& context = {});
 
    Response<Models::SubmitTransactionResult> SubmitTransaction(
        std::vector<Models::TransactionStep> const& steps,
        Core::Context const& context = {});
 
  private:
#ifdef _azure_TABLES_TESTING_BUILD
    friend class Azure::Data::Tables::StressTest::TransactionStressTest;
    friend class Azure::Data::Test::TransactionsBodyTest_TransactionCreate_Test;
    friend class Azure::Data::Test::TransactionsBodyTest_TransactionBodyInsertMergeOp_Test;
    friend class Azure::Data::Test::TransactionsBodyTest_TransactionBodyInsertReplaceOp_Test;
    friend class Azure::Data::Test::TransactionsBodyTest_TransactionBodyDeleteOp_Test;
    friend class Azure::Data::Test::TransactionsBodyTest_TransactionBodyUpdateMergeOp_Test;
    friend class Azure::Data::Test::TransactionsBodyTest_TransactionBodyUpdateReplaceOp_Test;
    friend class Azure::Data::Test::TransactionsBodyTest_TransactionBodyAddOp_Test;
#endif
 
    std::string PreparePayload(
        std::string const& batchId,
        std::string const& changesetId,
        std::vector<Models::TransactionStep> const& steps);
    std::string PrepAddEntity(std::string const& changesetId, Models::TableEntity entity);
    std::string PrepDeleteEntity(std::string const& changesetId, Models::TableEntity entity);
    std::string PrepMergeEntity(std::string const& changesetId, Models::TableEntity entity);
    std::string PrepUpdateEntity(std::string const& changesetId, Models::TableEntity entity);
    std::string PrepInsertEntity(std::string const& changesetId, Models::TableEntity entity);
    std::shared_ptr<Core::Http::_internal::HttpPipeline> m_pipeline;
    Core::Url m_url;
    std::string m_tableName;
  };
 
  class TableServiceClient final {
  public:
    explicit TableServiceClient(const TableClientOptions& options = {});
 
    explicit TableServiceClient(
        const std::string& serviceUrl,
        const TableClientOptions& options = {});
 
    explicit TableServiceClient(
        const std::string& serviceUrl,
        std::shared_ptr<Core::Credentials::TokenCredential> credential,
        const TableClientOptions& options = {});
 
    explicit TableServiceClient(
        const std::string& serviceUrl,
        std::shared_ptr<Azure::Data::Tables::Credentials::NamedKeyCredential> credential,
        const TableClientOptions& options = {});
 
    explicit TableServiceClient(
        const std::string& serviceUrl,
        std::shared_ptr<Azure::Data::Tables::Credentials::AzureSasCredential> credential,
        const TableClientOptions& options = {});
 
    static TableServiceClient CreateFromConnectionString(
        const std::string& connectionString,
        const TableClientOptions& options = {});
 
    Response<Models::Table> CreateTable(
        std::string const& tableName,
        Core::Context const& context = {});
 
    Response<Models::DeleteTableResult> DeleteTable(
        std::string const& tableName,
        Core::Context const& context = {});
 
    Models::QueryTablesPagedResponse QueryTables(
        const Models::QueryTablesOptions& options = {},
        const Azure::Core::Context& context = {}) const;
 
    Response<Models::SetServicePropertiesResult> SetServiceProperties(
        Models::SetServicePropertiesOptions const& options = {},
        Core::Context const& context = {});
 
    Response<Models::TableServiceProperties> GetServiceProperties(
        Core::Context const& context = {});
 
    Response<Models::ServiceStatistics> GetStatistics(Core::Context const& context = {});
 
    Response<Models::PreflightCheckResult> PreflightCheck(
        Models::PreflightCheckOptions const& options,
        Core::Context const& context = {});
    TableClient GetTableClient(const std::string& tableName, TableClientOptions const& options = {})
        const;
 
  private:
    std::shared_ptr<Core::Http::_internal::HttpPipeline> m_pipeline;
    std::shared_ptr<Core::Credentials::TokenCredential> m_tokenCredential;
    std::shared_ptr<Azure::Data::Tables::Credentials::NamedKeyCredential> m_namedKeyCredential;
    Core::Url m_url;
  };
}}} // namespace Azure::Data::Tables