org.openmetadata.client.api.DatabaseSchemasApi Maven / Gradle / Ivy
package org.openmetadata.client.api;
import org.openmetadata.client.ApiClient;
import org.openmetadata.client.EncodingUtils;
import org.openmetadata.client.model.ApiResponse;
import org.openmetadata.client.model.ChangeEvent;
import org.openmetadata.client.model.CreateDatabaseSchema;
import org.openmetadata.client.model.CsvImportResult;
import org.openmetadata.client.model.DatabaseSchema;
import org.openmetadata.client.model.DatabaseSchemaList;
import org.openmetadata.client.model.DatabaseSchemaProfilerConfig;
import org.openmetadata.client.model.EntityHistory;
import org.openmetadata.client.model.RestoreEntity;
import java.util.UUID;
import org.openmetadata.client.model.VoteRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import feign.*;
@javax.annotation.Generated(value = "org.openapitools.codegen.languages.JavaClientCodegen", date = "2024-09-13T20:15:57.513387948Z[Etc/UTC]")
public interface DatabaseSchemasApi extends ApiClient.Api {
/**
* Add databaseSchema profile config
* Add databaseSchema profile config to the table.
* @param id Id of the databaseSchema (required)
* @param databaseSchemaProfilerConfig (optional)
* @return DatabaseSchema
*/
@RequestLine("PUT /v1/databaseSchemas/{id}/databaseSchemaProfilerConfig")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
DatabaseSchema addDataProfilerConfig1(@Param("id") UUID id, DatabaseSchemaProfilerConfig databaseSchemaProfilerConfig);
/**
* Add databaseSchema profile config
* Similar to addDataProfilerConfig1 but it also returns the http response headers .
* Add databaseSchema profile config to the table.
* @param id Id of the databaseSchema (required)
* @param databaseSchemaProfilerConfig (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/databaseSchemas/{id}/databaseSchemaProfilerConfig")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse addDataProfilerConfig1WithHttpInfo(@Param("id") UUID id, DatabaseSchemaProfilerConfig databaseSchemaProfilerConfig);
/**
* Create a schema
* Create a schema under an existing `service`.
* @param createDatabaseSchema (optional)
* @return DatabaseSchema
*/
@RequestLine("POST /v1/databaseSchemas")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
DatabaseSchema createDBSchema(CreateDatabaseSchema createDatabaseSchema);
/**
* Create a schema
* Similar to createDBSchema but it also returns the http response headers .
* Create a schema under an existing `service`.
* @param createDatabaseSchema (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("POST /v1/databaseSchemas")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createDBSchemaWithHttpInfo(CreateDatabaseSchema createDatabaseSchema);
/**
* Create or update schema
* Create a database schema, if it does not exist or update an existing database schema.
* @param createDatabaseSchema (optional)
* @return DatabaseSchema
*/
@RequestLine("PUT /v1/databaseSchemas")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
DatabaseSchema createOrUpdateDBSchema(CreateDatabaseSchema createDatabaseSchema);
/**
* Create or update schema
* Similar to createOrUpdateDBSchema but it also returns the http response headers .
* Create a database schema, if it does not exist or update an existing database schema.
* @param createDatabaseSchema (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/databaseSchemas")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse createOrUpdateDBSchemaWithHttpInfo(CreateDatabaseSchema createDatabaseSchema);
/**
* Delete a schema by Id
* Delete a schema by `Id`. Schema can only be deleted if it has no tables.
* @param id Database schema Id (required)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/databaseSchemas/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteDBSchema(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a schema by Id
* Similar to deleteDBSchema but it also returns the http response headers .
* Delete a schema by `Id`. Schema can only be deleted if it has no tables.
* @param id Database schema Id (required)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/databaseSchemas/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteDBSchemaWithHttpInfo(@Param("id") UUID id, @Param("recursive") Boolean recursive, @Param("hardDelete") Boolean hardDelete);
/**
* Delete a schema by Id
* Delete a schema by `Id`. Schema can only be deleted if it has no tables.
* Note, this is equivalent to the other deleteDBSchema method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link DeleteDBSchemaQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Database schema Id (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/databaseSchemas/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
void deleteDBSchema(@Param("id") UUID id, @QueryMap(encoded=true) DeleteDBSchemaQueryParams queryParams);
/**
* Delete a schema by Id
* Delete a schema by `Id`. Schema can only be deleted if it has no tables.
* Note, this is equivalent to the other deleteDBSchema that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Database schema Id (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/databaseSchemas/{id}?recursive={recursive}&hardDelete={hardDelete}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteDBSchemaWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) DeleteDBSchemaQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteDBSchema method in a fluent style.
*/
public static class DeleteDBSchemaQueryParams extends HashMap {
public DeleteDBSchemaQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
public DeleteDBSchemaQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
}
/**
* Delete a schema by fully qualified name
* Delete a schema by `fullyQualifiedName`. Schema can only be deleted if it has no tables.
* @param fqn Name of the DBSchema (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/databaseSchemas/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteDBSchemaByFQN(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a schema by fully qualified name
* Similar to deleteDBSchemaByFQN but it also returns the http response headers .
* Delete a schema by `fullyQualifiedName`. Schema can only be deleted if it has no tables.
* @param fqn Name of the DBSchema (required)
* @param hardDelete Hard delete the entity. (Default = `false`) (optional, default to false)
* @param recursive Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*/
@RequestLine("DELETE /v1/databaseSchemas/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteDBSchemaByFQNWithHttpInfo(@Param("fqn") String fqn, @Param("hardDelete") Boolean hardDelete, @Param("recursive") Boolean recursive);
/**
* Delete a schema by fully qualified name
* Delete a schema by `fullyQualifiedName`. Schema can only be deleted if it has no tables.
* Note, this is equivalent to the other deleteDBSchemaByFQN method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link DeleteDBSchemaByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Name of the DBSchema (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/databaseSchemas/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
void deleteDBSchemaByFQN(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteDBSchemaByFQNQueryParams queryParams);
/**
* Delete a schema by fully qualified name
* Delete a schema by `fullyQualifiedName`. Schema can only be deleted if it has no tables.
* Note, this is equivalent to the other deleteDBSchemaByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Name of the DBSchema (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - hardDelete - Hard delete the entity. (Default = `false`) (optional, default to false)
* - recursive - Recursively delete this entity and it's children. (Default `false`) (optional, default to false)
*
*/
@RequestLine("DELETE /v1/databaseSchemas/name/{fqn}?hardDelete={hardDelete}&recursive={recursive}")
@Headers({
"Accept: application/json",
})
ApiResponse deleteDBSchemaByFQNWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) DeleteDBSchemaByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* deleteDBSchemaByFQN method in a fluent style.
*/
public static class DeleteDBSchemaByFQNQueryParams extends HashMap {
public DeleteDBSchemaByFQNQueryParams hardDelete(final Boolean value) {
put("hardDelete", EncodingUtils.encode(value));
return this;
}
public DeleteDBSchemaByFQNQueryParams recursive(final Boolean value) {
put("recursive", EncodingUtils.encode(value));
return this;
}
}
/**
* Delete database profiler config
* delete database profile config to the database.
* @param id Id of the table (required)
* @return DatabaseSchema
*/
@RequestLine("DELETE /v1/databaseSchemas/{id}/databaseSchemaProfilerConfig")
@Headers({
"Accept: application/json",
})
DatabaseSchema deleteDataProfilerConfig1(@Param("id") UUID id);
/**
* Delete database profiler config
* Similar to deleteDataProfilerConfig1 but it also returns the http response headers .
* delete database profile config to the database.
* @param id Id of the table (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("DELETE /v1/databaseSchemas/{id}/databaseSchemaProfilerConfig")
@Headers({
"Accept: application/json",
})
ApiResponse deleteDataProfilerConfig1WithHttpInfo(@Param("id") UUID id);
/**
* Export database schema in CSV format
*
* @param name Name of the Database schema (required)
* @return String
*/
@RequestLine("GET /v1/databaseSchemas/name/{name}/export")
@Headers({
"Accept: application/json",
})
String exportDatabaseSchema(@Param("name") String name);
/**
* Export database schema in CSV format
* Similar to exportDatabaseSchema but it also returns the http response headers .
*
* @param name Name of the Database schema (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/databaseSchemas/name/{name}/export")
@Headers({
"Accept: application/json",
})
ApiResponse exportDatabaseSchemaWithHttpInfo(@Param("name") String name);
/**
* Get a schema by fully qualified name
* Get a database schema by fully qualified name.
* @param fqn Fully qualified name of the database schema (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
DatabaseSchema getDBSchemaByFQN(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a schema by fully qualified name
* Similar to getDBSchemaByFQN but it also returns the http response headers .
* Get a database schema by fully qualified name.
* @param fqn Fully qualified name of the database schema (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/databaseSchemas/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getDBSchemaByFQNWithHttpInfo(@Param("fqn") String fqn, @Param("fields") String fields, @Param("include") String include);
/**
* Get a schema by fully qualified name
* Get a database schema by fully qualified name.
* Note, this is equivalent to the other getDBSchemaByFQN method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link GetDBSchemaByFQNQueryParams} class that allows for
* building up this map in a fluent style.
* @param fqn Fully qualified name of the database schema (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
DatabaseSchema getDBSchemaByFQN(@Param("fqn") String fqn, @QueryMap(encoded=true) GetDBSchemaByFQNQueryParams queryParams);
/**
* Get a schema by fully qualified name
* Get a database schema by fully qualified name.
* Note, this is equivalent to the other getDBSchemaByFQN that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param fqn Fully qualified name of the database schema (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/name/{fqn}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getDBSchemaByFQNWithHttpInfo(@Param("fqn") String fqn, @QueryMap(encoded=true) GetDBSchemaByFQNQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getDBSchemaByFQN method in a fluent style.
*/
public static class GetDBSchemaByFQNQueryParams extends HashMap {
public GetDBSchemaByFQNQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetDBSchemaByFQNQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get a schema by Id
* Get a database schema by `Id`.
* @param id Database schema Id (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
DatabaseSchema getDBSchemaByID(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a schema by Id
* Similar to getDBSchemaByID but it also returns the http response headers .
* Get a database schema by `Id`.
* @param id Database schema Id (required)
* @param fields Fields requested in the returned resource (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/databaseSchemas/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getDBSchemaByIDWithHttpInfo(@Param("id") UUID id, @Param("fields") String fields, @Param("include") String include);
/**
* Get a schema by Id
* Get a database schema by `Id`.
* Note, this is equivalent to the other getDBSchemaByID method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link GetDBSchemaByIDQueryParams} class that allows for
* building up this map in a fluent style.
* @param id Database schema Id (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
DatabaseSchema getDBSchemaByID(@Param("id") UUID id, @QueryMap(encoded=true) GetDBSchemaByIDQueryParams queryParams);
/**
* Get a schema by Id
* Get a database schema by `Id`.
* Note, this is equivalent to the other getDBSchemaByID that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param id Database schema Id (required)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/{id}?fields={fields}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse getDBSchemaByIDWithHttpInfo(@Param("id") UUID id, @QueryMap(encoded=true) GetDBSchemaByIDQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* getDBSchemaByID method in a fluent style.
*/
public static class GetDBSchemaByIDQueryParams extends HashMap {
public GetDBSchemaByIDQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public GetDBSchemaByIDQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Get databaseSchema profile config
* Get databaseSchema profile config to the table.
* @param id Id of the databaseSchema (required)
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/{id}/databaseSchemaProfilerConfig")
@Headers({
"Accept: application/json",
})
DatabaseSchema getDataProfilerConfig1(@Param("id") UUID id);
/**
* Get databaseSchema profile config
* Similar to getDataProfilerConfig1 but it also returns the http response headers .
* Get databaseSchema profile config to the table.
* @param id Id of the databaseSchema (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/databaseSchemas/{id}/databaseSchemaProfilerConfig")
@Headers({
"Accept: application/json",
})
ApiResponse getDataProfilerConfig1WithHttpInfo(@Param("id") UUID id);
/**
* Get a version of the schema
* Get a version of the database schema by given `Id`
* @param id Database schema Id (required)
* @param version Database schema version number in the form `major`.`minor` (required)
* @return DatabaseSchema
*/
@RequestLine("GET /v1/databaseSchemas/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
DatabaseSchema getSpecificDBSchemaVersion(@Param("id") UUID id, @Param("version") String version);
/**
* Get a version of the schema
* Similar to getSpecificDBSchemaVersion but it also returns the http response headers .
* Get a version of the database schema by given `Id`
* @param id Database schema Id (required)
* @param version Database schema version number in the form `major`.`minor` (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/databaseSchemas/{id}/versions/{version}")
@Headers({
"Accept: application/json",
})
ApiResponse getSpecificDBSchemaVersionWithHttpInfo(@Param("id") UUID id, @Param("version") String version);
/**
* Import tables from CSV to update database schema (no creation allowed)
*
* @param name Name of the Database schema (required)
* @param dryRun Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
* @param body (optional)
* @return CsvImportResult
*/
@RequestLine("PUT /v1/databaseSchemas/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
CsvImportResult importDatabaseSchema(@Param("name") String name, @Param("dryRun") Boolean dryRun, String body);
/**
* Import tables from CSV to update database schema (no creation allowed)
* Similar to importDatabaseSchema but it also returns the http response headers .
*
* @param name Name of the Database schema (required)
* @param dryRun Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
* @param body (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/databaseSchemas/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
ApiResponse importDatabaseSchemaWithHttpInfo(@Param("name") String name, @Param("dryRun") Boolean dryRun, String body);
/**
* Import tables from CSV to update database schema (no creation allowed)
*
* Note, this is equivalent to the other importDatabaseSchema method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link ImportDatabaseSchemaQueryParams} class that allows for
* building up this map in a fluent style.
* @param name Name of the Database schema (required)
* @param body (optional)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - dryRun - Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
*
* @return CsvImportResult
*/
@RequestLine("PUT /v1/databaseSchemas/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
CsvImportResult importDatabaseSchema(@Param("name") String name, String body, @QueryMap(encoded=true) ImportDatabaseSchemaQueryParams queryParams);
/**
* Import tables from CSV to update database schema (no creation allowed)
*
* Note, this is equivalent to the other importDatabaseSchema that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param name Name of the Database schema (required)
* @param body (optional)
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - dryRun - Dry-run when true is used for validating the CSV without really importing it. (default=true) (optional, default to true)
*
* @return CsvImportResult
*/
@RequestLine("PUT /v1/databaseSchemas/name/{name}/import?dryRun={dryRun}")
@Headers({
"Content-Type: text/plain",
"Accept: application/json",
})
ApiResponse importDatabaseSchemaWithHttpInfo(@Param("name") String name, String body, @QueryMap(encoded=true) ImportDatabaseSchemaQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* importDatabaseSchema method in a fluent style.
*/
public static class ImportDatabaseSchemaQueryParams extends HashMap {
public ImportDatabaseSchemaQueryParams dryRun(final Boolean value) {
put("dryRun", EncodingUtils.encode(value));
return this;
}
}
/**
* List schema versions
* Get a list of all the versions of a schema identified by `Id`
* @param id Database schema Id (required)
* @return EntityHistory
*/
@RequestLine("GET /v1/databaseSchemas/{id}/versions")
@Headers({
"Accept: application/json",
})
EntityHistory listAllDBSchemaVersion(@Param("id") UUID id);
/**
* List schema versions
* Similar to listAllDBSchemaVersion but it also returns the http response headers .
* Get a list of all the versions of a schema identified by `Id`
* @param id Database schema Id (required)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/databaseSchemas/{id}/versions")
@Headers({
"Accept: application/json",
})
ApiResponse listAllDBSchemaVersionWithHttpInfo(@Param("id") UUID id);
/**
* List database schemas
* Get a list of database schemas, optionally filtered by `database` it belongs to. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* @param fields Fields requested in the returned resource (optional)
* @param database Filter schemas by database name (optional)
* @param limit Limit the number schemas returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of schemas before this cursor (optional)
* @param after Returns list of schemas after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return DatabaseSchemaList
*/
@RequestLine("GET /v1/databaseSchemas?fields={fields}&database={database}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
DatabaseSchemaList listDBSchemas(@Param("fields") String fields, @Param("database") String database, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List database schemas
* Similar to listDBSchemas but it also returns the http response headers .
* Get a list of database schemas, optionally filtered by `database` it belongs to. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* @param fields Fields requested in the returned resource (optional)
* @param database Filter schemas by database name (optional)
* @param limit Limit the number schemas returned. (1 to 1000000, default = 10) (optional, default to 10)
* @param before Returns list of schemas before this cursor (optional)
* @param after Returns list of schemas after this cursor (optional)
* @param include Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("GET /v1/databaseSchemas?fields={fields}&database={database}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listDBSchemasWithHttpInfo(@Param("fields") String fields, @Param("database") String database, @Param("limit") Integer limit, @Param("before") String before, @Param("after") String after, @Param("include") String include);
/**
* List database schemas
* Get a list of database schemas, optionally filtered by `database` it belongs to. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* Note, this is equivalent to the other listDBSchemas method,
* but with the query parameters collected into a single Map parameter. This
* is convenient for services with optional query parameters, especially when
* used with the {@link ListDBSchemasQueryParams} class that allows for
* building up this map in a fluent style.
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - database - Filter schemas by database name (optional)
* - limit - Limit the number schemas returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of schemas before this cursor (optional)
* - after - Returns list of schemas after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return DatabaseSchemaList
*/
@RequestLine("GET /v1/databaseSchemas?fields={fields}&database={database}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
DatabaseSchemaList listDBSchemas(@QueryMap(encoded=true) ListDBSchemasQueryParams queryParams);
/**
* List database schemas
* Get a list of database schemas, optionally filtered by `database` it belongs to. Use `fields` parameter to get only necessary fields. Use cursor-based pagination to limit the number entries in the list using `limit` and `before` or `after` query params.
* Note, this is equivalent to the other listDBSchemas that receives the query parameters as a map,
* but this one also exposes the Http response headers
* @param queryParams Map of query parameters as name-value pairs
* The following elements may be specified in the query map:
*
* - fields - Fields requested in the returned resource (optional)
* - database - Filter schemas by database name (optional)
* - limit - Limit the number schemas returned. (1 to 1000000, default = 10) (optional, default to 10)
* - before - Returns list of schemas before this cursor (optional)
* - after - Returns list of schemas after this cursor (optional)
* - include - Include all, deleted, or non-deleted entities. (optional, default to non-deleted)
*
* @return DatabaseSchemaList
*/
@RequestLine("GET /v1/databaseSchemas?fields={fields}&database={database}&limit={limit}&before={before}&after={after}&include={include}")
@Headers({
"Accept: application/json",
})
ApiResponse listDBSchemasWithHttpInfo(@QueryMap(encoded=true) ListDBSchemasQueryParams queryParams);
/**
* A convenience class for generating query parameters for the
* listDBSchemas method in a fluent style.
*/
public static class ListDBSchemasQueryParams extends HashMap {
public ListDBSchemasQueryParams fields(final String value) {
put("fields", EncodingUtils.encode(value));
return this;
}
public ListDBSchemasQueryParams database(final String value) {
put("database", EncodingUtils.encode(value));
return this;
}
public ListDBSchemasQueryParams limit(final Integer value) {
put("limit", EncodingUtils.encode(value));
return this;
}
public ListDBSchemasQueryParams before(final String value) {
put("before", EncodingUtils.encode(value));
return this;
}
public ListDBSchemasQueryParams after(final String value) {
put("after", EncodingUtils.encode(value));
return this;
}
public ListDBSchemasQueryParams include(final String value) {
put("include", EncodingUtils.encode(value));
return this;
}
}
/**
* Update a database schema by name.
* Update an existing database schema using JsonPatch.
* @param fqn Database schema name (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a database schema by name. Documentation
*/
@RequestLine("PATCH /v1/databaseSchemas/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchDBSchema(@Param("fqn") String fqn, Object body);
/**
* Update a database schema by name.
* Similar to patchDBSchema but it also returns the http response headers .
* Update an existing database schema using JsonPatch.
* @param fqn Database schema name (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a database schema by name. Documentation
*/
@RequestLine("PATCH /v1/databaseSchemas/name/{fqn}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchDBSchemaWithHttpInfo(@Param("fqn") String fqn, Object body);
/**
* Update a database schema
* Update an existing database schema using JsonPatch.
* @param id Database schema Id (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a database schema Documentation
*/
@RequestLine("PATCH /v1/databaseSchemas/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
void patchDBSchema1(@Param("id") UUID id, Object body);
/**
* Update a database schema
* Similar to patchDBSchema1 but it also returns the http response headers .
* Update an existing database schema using JsonPatch.
* @param id Database schema Id (required)
* @param body JsonPatch with array of operations (optional)
* JsonPatch RFC
* @see Update a database schema Documentation
*/
@RequestLine("PATCH /v1/databaseSchemas/{id}")
@Headers({
"Content-Type: application/json-patch+json",
"Accept: application/json",
})
ApiResponse patchDBSchema1WithHttpInfo(@Param("id") UUID id, Object body);
/**
* Restore a soft deleted database schema.
* Restore a soft deleted database schema.
* @param restoreEntity (optional)
* @return DatabaseSchema
*/
@RequestLine("PUT /v1/databaseSchemas/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
DatabaseSchema restore8(RestoreEntity restoreEntity);
/**
* Restore a soft deleted database schema.
* Similar to restore8 but it also returns the http response headers .
* Restore a soft deleted database schema.
* @param restoreEntity (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/databaseSchemas/restore")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse restore8WithHttpInfo(RestoreEntity restoreEntity);
/**
* Update Vote for a Entity
* Update vote for a Entity
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return ChangeEvent
*/
@RequestLine("PUT /v1/databaseSchemas/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ChangeEvent updateVoteForEntity3(@Param("id") UUID id, VoteRequest voteRequest);
/**
* Update Vote for a Entity
* Similar to updateVoteForEntity3 but it also returns the http response headers .
* Update vote for a Entity
* @param id Id of the Entity (required)
* @param voteRequest (optional)
* @return A ApiResponse that wraps the response boyd and the http headers.
*/
@RequestLine("PUT /v1/databaseSchemas/{id}/vote")
@Headers({
"Content-Type: application/json",
"Accept: application/json",
})
ApiResponse updateVoteForEntity3WithHttpInfo(@Param("id") UUID id, VoteRequest voteRequest);
}