class OCI::DatabaseManagement::Models::TablespaceSummary

The summary of a tablespace.

Constants

ALLOCATION_TYPE_ENUM
COMPRESS_FOR_ENUM
DEFAULT_INDEX_COMPRESSION_ENUM
DEFAULT_IN_MEMORY_COMPRESSION_ENUM
DEFAULT_IN_MEMORY_DISTRIBUTE_ENUM
DEFAULT_IN_MEMORY_DUPLICATE_ENUM
DEFAULT_IN_MEMORY_ENUM
DEFAULT_IN_MEMORY_PRIORITY_ENUM
DEFAULT_IN_MEMORY_SERVICE_ENUM
DEFAULT_TABLE_COMPRESSION_ENUM
EXTENT_MANAGEMENT_ENUM
INDEX_COMPRESS_FOR_ENUM
LOGGING_ENUM
LOST_WRITE_PROTECT_ENUM
PREDICATE_EVALUATION_ENUM
RETENTION_ENUM
SEGMENT_SPACE_MANAGEMENT_ENUM
SHARED_ENUM
STATUS_ENUM
TYPE_ENUM

Attributes

allocated_size_kb[RW]

The allocated tablespace size in KB. @return [Float]

allocation_type[R]

The type of extent allocation in effect for the tablespace. @return [String]

block_size_bytes[RW]

The tablespace block size in bytes. @return [Float]

compress_for[R]

The operation type for which default compression is enabled. @return [String]

datafiles[RW]

A list of the datafiles associated with the tablespace. @return [Array<OCI::DatabaseManagement::Models::Datafile>]

default_cell_memory[RW]

This specifies the default value for the CELLMEMORY attribute that tables created in the tablespace will inherit unless the behavior is overridden explicitly. This column is intended for use with Oracle Exadata. @return [String]

default_in_memory[R]

Indicates whether the In-Memory Column Store (IM column store) is by default enabled or disabled for tables in this tablespace. @return [String]

default_in_memory_compression[R]

Indicates the default compression level for the IM column store for this tablespace. @return [String]

default_in_memory_distribute[R]

Indicates how the IM column store is distributed by default for this tablespace in an Oracle Real Application Clusters (Oracle RAC) environment. @return [String]

default_in_memory_duplicate[R]

Indicates the duplicate setting for the IM column store in an Oracle RAC environment. @return [String]

default_in_memory_priority[R]

Indicates the default priority for In-Memory Column Store (IM column store) population for this tablespace. @return [String]

default_in_memory_service[R]

Indicates how the IM column store is populated on various instances by default for this tablespace. @return [String]

default_in_memory_service_name[RW]

Indicates the service name for the service on which the IM column store should be populated by default for this tablespace. This column has a value only when the corresponding DEF_INMEMORY_SERVICE is USER_DEFINED. In all other cases, this column is null. @return [String]

default_index_compression[R]

Indicates whether default index compression is enabled or disabled. @return [String]

default_table_compression[R]

Indicates whether default table compression is enabled or disabled. @return [String]

extent_management[R]

Indicates whether the extents in the tablespace are Locally managed or Dictionary managed. @return [String]

free_space_kb[RW]

The free space available in this tablespace in KB. @return [Float]

index_compress_for[R]

The operation type for which default index compression is enabled. @return [String]

is_bigfile[RW]

Indicates whether the tablespace is a Bigfile tablespace or a Smallfile tablespace. @return [BOOLEAN]

is_chunk_tablespace[RW]

Indicates whether this is a chunk tablespace. @return [BOOLEAN]

is_encrypted[RW]

Indicates whether the tablespace is encrypted. @return [BOOLEAN]

is_force_logging[RW]

Indicates whether the tablespace is under Force Logging mode. @return [BOOLEAN]

is_plugged_in[RW]

Indicates whether the tablespace is plugged in. @return [BOOLEAN]

logging[R]

The default logging attribute. @return [String]

lost_write_protect[R]

The lost write protection setting for the tablespace. @return [String]

max_size_kb[RW]

The maximum tablespace size in KB. If the tablespace contains any datafiles with Autoextend enabled, then this column displays the amount of underlying free storage space for the tablespace. For example, if the current tablespace size is 1 GB, the combined maximum size of all its datafiles is 32 GB, and its underlying storage (for example, ASM or file system storage) has 20 GB of free space, then this column will have a value of approximately 20 GB. If the tablespace contains only datafiles with autoextend disabled, then this column displays the allocated space for the entire tablespace, that is, the combined size of all datafiles in the tablespace. @return [Float]

name[RW]

[Required] The name of the tablespace. @return [String]

predicate_evaluation[R]

Indicates whether predicates are evaluated by Host or by Storage. @return [String]

retention[R]

Indicates whether undo retention guarantee is enabled for the tablespace. @return [String]

segment_space_management[R]

Indicates whether the free and used segment space in the tablespace is managed using free lists (MANUAL) or bitmaps (AUTO). @return [String]

shared[R]

Indicates whether the tablespace is for shared tablespace, or for local temporary tablespace for leaf (read-only) instances, or for local temporary tablespace for all instance types. @return [String]

status[R]

The status of the tablespace. @return [String]

temp_group[RW]

The temporary tablespace group. @return [String]

type[R]

[Required] The type of the tablespace. @return [String]

used_percent_allocated[RW]

The percentage of used space out of the total allocated space in the tablespace. @return [Float]

used_percent_available[RW]

The percentage of used space out of the maximum available space in the tablespace. @return [Float]

used_space_kb[RW]

The total space used by the tablespace in KB. @return [Float]

user_size_kb[RW]

The size of the tablespace available for user data in KB. The difference between tablespace size and user data size is used for storing metadata. @return [Float]

Public Class Methods

attribute_map() click to toggle source

Attribute mapping from ruby-style variable name to JSON key.

# File lib/oci/database_management/models/tablespace_summary.rb, line 309
def self.attribute_map
  {
    # rubocop:disable Style/SymbolLiteral
    'name': :'name',
    'type': :'type',
    'status': :'status',
    'block_size_bytes': :'blockSizeBytes',
    'logging': :'logging',
    'is_force_logging': :'isForceLogging',
    'extent_management': :'extentManagement',
    'allocation_type': :'allocationType',
    'is_plugged_in': :'isPluggedIn',
    'segment_space_management': :'segmentSpaceManagement',
    'default_table_compression': :'defaultTableCompression',
    'retention': :'retention',
    'is_bigfile': :'isBigfile',
    'predicate_evaluation': :'predicateEvaluation',
    'is_encrypted': :'isEncrypted',
    'compress_for': :'compressFor',
    'default_in_memory': :'defaultInMemory',
    'default_in_memory_priority': :'defaultInMemoryPriority',
    'default_in_memory_distribute': :'defaultInMemoryDistribute',
    'default_in_memory_compression': :'defaultInMemoryCompression',
    'default_in_memory_duplicate': :'defaultInMemoryDuplicate',
    'shared': :'shared',
    'default_index_compression': :'defaultIndexCompression',
    'index_compress_for': :'indexCompressFor',
    'default_cell_memory': :'defaultCellMemory',
    'default_in_memory_service': :'defaultInMemoryService',
    'default_in_memory_service_name': :'defaultInMemoryServiceName',
    'lost_write_protect': :'lostWriteProtect',
    'is_chunk_tablespace': :'isChunkTablespace',
    'temp_group': :'tempGroup',
    'max_size_kb': :'maxSizeKB',
    'allocated_size_kb': :'allocatedSizeKB',
    'user_size_kb': :'userSizeKB',
    'free_space_kb': :'freeSpaceKB',
    'used_space_kb': :'usedSpaceKB',
    'used_percent_available': :'usedPercentAvailable',
    'used_percent_allocated': :'usedPercentAllocated',
    'datafiles': :'datafiles'
    # rubocop:enable Style/SymbolLiteral
  }
end
new(attributes = {}) click to toggle source

Initializes the object @param [Hash] attributes Model attributes in the form of hash @option attributes [String] :name The value to assign to the {#name} property @option attributes [String] :type The value to assign to the {#type} property @option attributes [String] :status The value to assign to the {#status} property @option attributes [Float] :block_size_bytes The value to assign to the {#block_size_bytes} property @option attributes [String] :logging The value to assign to the {#logging} property @option attributes [BOOLEAN] :is_force_logging The value to assign to the {#is_force_logging} property @option attributes [String] :extent_management The value to assign to the {#extent_management} property @option attributes [String] :allocation_type The value to assign to the {#allocation_type} property @option attributes [BOOLEAN] :is_plugged_in The value to assign to the {#is_plugged_in} property @option attributes [String] :segment_space_management The value to assign to the {#segment_space_management} property @option attributes [String] :default_table_compression The value to assign to the {#default_table_compression} property @option attributes [String] :retention The value to assign to the {#retention} property @option attributes [BOOLEAN] :is_bigfile The value to assign to the {#is_bigfile} property @option attributes [String] :predicate_evaluation The value to assign to the {#predicate_evaluation} property @option attributes [BOOLEAN] :is_encrypted The value to assign to the {#is_encrypted} property @option attributes [String] :compress_for The value to assign to the {#compress_for} property @option attributes [String] :default_in_memory The value to assign to the {#default_in_memory} property @option attributes [String] :default_in_memory_priority The value to assign to the {#default_in_memory_priority} property @option attributes [String] :default_in_memory_distribute The value to assign to the {#default_in_memory_distribute} property @option attributes [String] :default_in_memory_compression The value to assign to the {#default_in_memory_compression} property @option attributes [String] :default_in_memory_duplicate The value to assign to the {#default_in_memory_duplicate} property @option attributes [String] :shared The value to assign to the {#shared} property @option attributes [String] :default_index_compression The value to assign to the {#default_index_compression} property @option attributes [String] :index_compress_for The value to assign to the {#index_compress_for} property @option attributes [String] :default_cell_memory The value to assign to the {#default_cell_memory} property @option attributes [String] :default_in_memory_service The value to assign to the {#default_in_memory_service} property @option attributes [String] :default_in_memory_service_name The value to assign to the {#default_in_memory_service_name} property @option attributes [String] :lost_write_protect The value to assign to the {#lost_write_protect} property @option attributes [BOOLEAN] :is_chunk_tablespace The value to assign to the {#is_chunk_tablespace} property @option attributes [String] :temp_group The value to assign to the {#temp_group} property @option attributes [Float] :max_size_kb The value to assign to the {#max_size_kb} property @option attributes [Float] :allocated_size_kb The value to assign to the {#allocated_size_kb} property @option attributes [Float] :user_size_kb The value to assign to the {#user_size_kb} property @option attributes [Float] :free_space_kb The value to assign to the {#free_space_kb} property @option attributes [Float] :used_space_kb The value to assign to the {#used_space_kb} property @option attributes [Float] :used_percent_available The value to assign to the {#used_percent_available} property @option attributes [Float] :used_percent_allocated The value to assign to the {#used_percent_allocated} property @option attributes [Array<OCI::DatabaseManagement::Models::Datafile>] :datafiles The value to assign to the {#datafiles} property

# File lib/oci/database_management/models/tablespace_summary.rb, line 444
def initialize(attributes = {})
  return unless attributes.is_a?(Hash)

  # convert string to symbol for hash key
  attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }

  self.name = attributes[:'name'] if attributes[:'name']

  self.type = attributes[:'type'] if attributes[:'type']

  self.status = attributes[:'status'] if attributes[:'status']

  self.block_size_bytes = attributes[:'blockSizeBytes'] if attributes[:'blockSizeBytes']

  raise 'You cannot provide both :blockSizeBytes and :block_size_bytes' if attributes.key?(:'blockSizeBytes') && attributes.key?(:'block_size_bytes')

  self.block_size_bytes = attributes[:'block_size_bytes'] if attributes[:'block_size_bytes']

  self.logging = attributes[:'logging'] if attributes[:'logging']

  self.is_force_logging = attributes[:'isForceLogging'] unless attributes[:'isForceLogging'].nil?

  raise 'You cannot provide both :isForceLogging and :is_force_logging' if attributes.key?(:'isForceLogging') && attributes.key?(:'is_force_logging')

  self.is_force_logging = attributes[:'is_force_logging'] unless attributes[:'is_force_logging'].nil?

  self.extent_management = attributes[:'extentManagement'] if attributes[:'extentManagement']

  raise 'You cannot provide both :extentManagement and :extent_management' if attributes.key?(:'extentManagement') && attributes.key?(:'extent_management')

  self.extent_management = attributes[:'extent_management'] if attributes[:'extent_management']

  self.allocation_type = attributes[:'allocationType'] if attributes[:'allocationType']

  raise 'You cannot provide both :allocationType and :allocation_type' if attributes.key?(:'allocationType') && attributes.key?(:'allocation_type')

  self.allocation_type = attributes[:'allocation_type'] if attributes[:'allocation_type']

  self.is_plugged_in = attributes[:'isPluggedIn'] unless attributes[:'isPluggedIn'].nil?

  raise 'You cannot provide both :isPluggedIn and :is_plugged_in' if attributes.key?(:'isPluggedIn') && attributes.key?(:'is_plugged_in')

  self.is_plugged_in = attributes[:'is_plugged_in'] unless attributes[:'is_plugged_in'].nil?

  self.segment_space_management = attributes[:'segmentSpaceManagement'] if attributes[:'segmentSpaceManagement']

  raise 'You cannot provide both :segmentSpaceManagement and :segment_space_management' if attributes.key?(:'segmentSpaceManagement') && attributes.key?(:'segment_space_management')

  self.segment_space_management = attributes[:'segment_space_management'] if attributes[:'segment_space_management']

  self.default_table_compression = attributes[:'defaultTableCompression'] if attributes[:'defaultTableCompression']

  raise 'You cannot provide both :defaultTableCompression and :default_table_compression' if attributes.key?(:'defaultTableCompression') && attributes.key?(:'default_table_compression')

  self.default_table_compression = attributes[:'default_table_compression'] if attributes[:'default_table_compression']

  self.retention = attributes[:'retention'] if attributes[:'retention']

  self.is_bigfile = attributes[:'isBigfile'] unless attributes[:'isBigfile'].nil?

  raise 'You cannot provide both :isBigfile and :is_bigfile' if attributes.key?(:'isBigfile') && attributes.key?(:'is_bigfile')

  self.is_bigfile = attributes[:'is_bigfile'] unless attributes[:'is_bigfile'].nil?

  self.predicate_evaluation = attributes[:'predicateEvaluation'] if attributes[:'predicateEvaluation']

  raise 'You cannot provide both :predicateEvaluation and :predicate_evaluation' if attributes.key?(:'predicateEvaluation') && attributes.key?(:'predicate_evaluation')

  self.predicate_evaluation = attributes[:'predicate_evaluation'] if attributes[:'predicate_evaluation']

  self.is_encrypted = attributes[:'isEncrypted'] unless attributes[:'isEncrypted'].nil?

  raise 'You cannot provide both :isEncrypted and :is_encrypted' if attributes.key?(:'isEncrypted') && attributes.key?(:'is_encrypted')

  self.is_encrypted = attributes[:'is_encrypted'] unless attributes[:'is_encrypted'].nil?

  self.compress_for = attributes[:'compressFor'] if attributes[:'compressFor']

  raise 'You cannot provide both :compressFor and :compress_for' if attributes.key?(:'compressFor') && attributes.key?(:'compress_for')

  self.compress_for = attributes[:'compress_for'] if attributes[:'compress_for']

  self.default_in_memory = attributes[:'defaultInMemory'] if attributes[:'defaultInMemory']

  raise 'You cannot provide both :defaultInMemory and :default_in_memory' if attributes.key?(:'defaultInMemory') && attributes.key?(:'default_in_memory')

  self.default_in_memory = attributes[:'default_in_memory'] if attributes[:'default_in_memory']

  self.default_in_memory_priority = attributes[:'defaultInMemoryPriority'] if attributes[:'defaultInMemoryPriority']

  raise 'You cannot provide both :defaultInMemoryPriority and :default_in_memory_priority' if attributes.key?(:'defaultInMemoryPriority') && attributes.key?(:'default_in_memory_priority')

  self.default_in_memory_priority = attributes[:'default_in_memory_priority'] if attributes[:'default_in_memory_priority']

  self.default_in_memory_distribute = attributes[:'defaultInMemoryDistribute'] if attributes[:'defaultInMemoryDistribute']

  raise 'You cannot provide both :defaultInMemoryDistribute and :default_in_memory_distribute' if attributes.key?(:'defaultInMemoryDistribute') && attributes.key?(:'default_in_memory_distribute')

  self.default_in_memory_distribute = attributes[:'default_in_memory_distribute'] if attributes[:'default_in_memory_distribute']

  self.default_in_memory_compression = attributes[:'defaultInMemoryCompression'] if attributes[:'defaultInMemoryCompression']

  raise 'You cannot provide both :defaultInMemoryCompression and :default_in_memory_compression' if attributes.key?(:'defaultInMemoryCompression') && attributes.key?(:'default_in_memory_compression')

  self.default_in_memory_compression = attributes[:'default_in_memory_compression'] if attributes[:'default_in_memory_compression']

  self.default_in_memory_duplicate = attributes[:'defaultInMemoryDuplicate'] if attributes[:'defaultInMemoryDuplicate']

  raise 'You cannot provide both :defaultInMemoryDuplicate and :default_in_memory_duplicate' if attributes.key?(:'defaultInMemoryDuplicate') && attributes.key?(:'default_in_memory_duplicate')

  self.default_in_memory_duplicate = attributes[:'default_in_memory_duplicate'] if attributes[:'default_in_memory_duplicate']

  self.shared = attributes[:'shared'] if attributes[:'shared']

  self.default_index_compression = attributes[:'defaultIndexCompression'] if attributes[:'defaultIndexCompression']

  raise 'You cannot provide both :defaultIndexCompression and :default_index_compression' if attributes.key?(:'defaultIndexCompression') && attributes.key?(:'default_index_compression')

  self.default_index_compression = attributes[:'default_index_compression'] if attributes[:'default_index_compression']

  self.index_compress_for = attributes[:'indexCompressFor'] if attributes[:'indexCompressFor']

  raise 'You cannot provide both :indexCompressFor and :index_compress_for' if attributes.key?(:'indexCompressFor') && attributes.key?(:'index_compress_for')

  self.index_compress_for = attributes[:'index_compress_for'] if attributes[:'index_compress_for']

  self.default_cell_memory = attributes[:'defaultCellMemory'] if attributes[:'defaultCellMemory']

  raise 'You cannot provide both :defaultCellMemory and :default_cell_memory' if attributes.key?(:'defaultCellMemory') && attributes.key?(:'default_cell_memory')

  self.default_cell_memory = attributes[:'default_cell_memory'] if attributes[:'default_cell_memory']

  self.default_in_memory_service = attributes[:'defaultInMemoryService'] if attributes[:'defaultInMemoryService']

  raise 'You cannot provide both :defaultInMemoryService and :default_in_memory_service' if attributes.key?(:'defaultInMemoryService') && attributes.key?(:'default_in_memory_service')

  self.default_in_memory_service = attributes[:'default_in_memory_service'] if attributes[:'default_in_memory_service']

  self.default_in_memory_service_name = attributes[:'defaultInMemoryServiceName'] if attributes[:'defaultInMemoryServiceName']

  raise 'You cannot provide both :defaultInMemoryServiceName and :default_in_memory_service_name' if attributes.key?(:'defaultInMemoryServiceName') && attributes.key?(:'default_in_memory_service_name')

  self.default_in_memory_service_name = attributes[:'default_in_memory_service_name'] if attributes[:'default_in_memory_service_name']

  self.lost_write_protect = attributes[:'lostWriteProtect'] if attributes[:'lostWriteProtect']

  raise 'You cannot provide both :lostWriteProtect and :lost_write_protect' if attributes.key?(:'lostWriteProtect') && attributes.key?(:'lost_write_protect')

  self.lost_write_protect = attributes[:'lost_write_protect'] if attributes[:'lost_write_protect']

  self.is_chunk_tablespace = attributes[:'isChunkTablespace'] unless attributes[:'isChunkTablespace'].nil?

  raise 'You cannot provide both :isChunkTablespace and :is_chunk_tablespace' if attributes.key?(:'isChunkTablespace') && attributes.key?(:'is_chunk_tablespace')

  self.is_chunk_tablespace = attributes[:'is_chunk_tablespace'] unless attributes[:'is_chunk_tablespace'].nil?

  self.temp_group = attributes[:'tempGroup'] if attributes[:'tempGroup']

  raise 'You cannot provide both :tempGroup and :temp_group' if attributes.key?(:'tempGroup') && attributes.key?(:'temp_group')

  self.temp_group = attributes[:'temp_group'] if attributes[:'temp_group']

  self.max_size_kb = attributes[:'maxSizeKB'] if attributes[:'maxSizeKB']

  raise 'You cannot provide both :maxSizeKB and :max_size_kb' if attributes.key?(:'maxSizeKB') && attributes.key?(:'max_size_kb')

  self.max_size_kb = attributes[:'max_size_kb'] if attributes[:'max_size_kb']

  self.allocated_size_kb = attributes[:'allocatedSizeKB'] if attributes[:'allocatedSizeKB']

  raise 'You cannot provide both :allocatedSizeKB and :allocated_size_kb' if attributes.key?(:'allocatedSizeKB') && attributes.key?(:'allocated_size_kb')

  self.allocated_size_kb = attributes[:'allocated_size_kb'] if attributes[:'allocated_size_kb']

  self.user_size_kb = attributes[:'userSizeKB'] if attributes[:'userSizeKB']

  raise 'You cannot provide both :userSizeKB and :user_size_kb' if attributes.key?(:'userSizeKB') && attributes.key?(:'user_size_kb')

  self.user_size_kb = attributes[:'user_size_kb'] if attributes[:'user_size_kb']

  self.free_space_kb = attributes[:'freeSpaceKB'] if attributes[:'freeSpaceKB']

  raise 'You cannot provide both :freeSpaceKB and :free_space_kb' if attributes.key?(:'freeSpaceKB') && attributes.key?(:'free_space_kb')

  self.free_space_kb = attributes[:'free_space_kb'] if attributes[:'free_space_kb']

  self.used_space_kb = attributes[:'usedSpaceKB'] if attributes[:'usedSpaceKB']

  raise 'You cannot provide both :usedSpaceKB and :used_space_kb' if attributes.key?(:'usedSpaceKB') && attributes.key?(:'used_space_kb')

  self.used_space_kb = attributes[:'used_space_kb'] if attributes[:'used_space_kb']

  self.used_percent_available = attributes[:'usedPercentAvailable'] if attributes[:'usedPercentAvailable']

  raise 'You cannot provide both :usedPercentAvailable and :used_percent_available' if attributes.key?(:'usedPercentAvailable') && attributes.key?(:'used_percent_available')

  self.used_percent_available = attributes[:'used_percent_available'] if attributes[:'used_percent_available']

  self.used_percent_allocated = attributes[:'usedPercentAllocated'] if attributes[:'usedPercentAllocated']

  raise 'You cannot provide both :usedPercentAllocated and :used_percent_allocated' if attributes.key?(:'usedPercentAllocated') && attributes.key?(:'used_percent_allocated')

  self.used_percent_allocated = attributes[:'used_percent_allocated'] if attributes[:'used_percent_allocated']

  self.datafiles = attributes[:'datafiles'] if attributes[:'datafiles']
end
swagger_types() click to toggle source

Attribute type mapping.

# File lib/oci/database_management/models/tablespace_summary.rb, line 355
def self.swagger_types
  {
    # rubocop:disable Style/SymbolLiteral
    'name': :'String',
    'type': :'String',
    'status': :'String',
    'block_size_bytes': :'Float',
    'logging': :'String',
    'is_force_logging': :'BOOLEAN',
    'extent_management': :'String',
    'allocation_type': :'String',
    'is_plugged_in': :'BOOLEAN',
    'segment_space_management': :'String',
    'default_table_compression': :'String',
    'retention': :'String',
    'is_bigfile': :'BOOLEAN',
    'predicate_evaluation': :'String',
    'is_encrypted': :'BOOLEAN',
    'compress_for': :'String',
    'default_in_memory': :'String',
    'default_in_memory_priority': :'String',
    'default_in_memory_distribute': :'String',
    'default_in_memory_compression': :'String',
    'default_in_memory_duplicate': :'String',
    'shared': :'String',
    'default_index_compression': :'String',
    'index_compress_for': :'String',
    'default_cell_memory': :'String',
    'default_in_memory_service': :'String',
    'default_in_memory_service_name': :'String',
    'lost_write_protect': :'String',
    'is_chunk_tablespace': :'BOOLEAN',
    'temp_group': :'String',
    'max_size_kb': :'Float',
    'allocated_size_kb': :'Float',
    'user_size_kb': :'Float',
    'free_space_kb': :'Float',
    'used_space_kb': :'Float',
    'used_percent_available': :'Float',
    'used_percent_allocated': :'Float',
    'datafiles': :'Array<OCI::DatabaseManagement::Models::Datafile>'
    # rubocop:enable Style/SymbolLiteral
  }
end

Public Instance Methods

==(other) click to toggle source

Checks equality by comparing each attribute. @param [Object] other the other object to be compared

# File lib/oci/database_management/models/tablespace_summary.rb, line 918
def ==(other)
  return true if equal?(other)

  self.class == other.class &&
    name == other.name &&
    type == other.type &&
    status == other.status &&
    block_size_bytes == other.block_size_bytes &&
    logging == other.logging &&
    is_force_logging == other.is_force_logging &&
    extent_management == other.extent_management &&
    allocation_type == other.allocation_type &&
    is_plugged_in == other.is_plugged_in &&
    segment_space_management == other.segment_space_management &&
    default_table_compression == other.default_table_compression &&
    retention == other.retention &&
    is_bigfile == other.is_bigfile &&
    predicate_evaluation == other.predicate_evaluation &&
    is_encrypted == other.is_encrypted &&
    compress_for == other.compress_for &&
    default_in_memory == other.default_in_memory &&
    default_in_memory_priority == other.default_in_memory_priority &&
    default_in_memory_distribute == other.default_in_memory_distribute &&
    default_in_memory_compression == other.default_in_memory_compression &&
    default_in_memory_duplicate == other.default_in_memory_duplicate &&
    shared == other.shared &&
    default_index_compression == other.default_index_compression &&
    index_compress_for == other.index_compress_for &&
    default_cell_memory == other.default_cell_memory &&
    default_in_memory_service == other.default_in_memory_service &&
    default_in_memory_service_name == other.default_in_memory_service_name &&
    lost_write_protect == other.lost_write_protect &&
    is_chunk_tablespace == other.is_chunk_tablespace &&
    temp_group == other.temp_group &&
    max_size_kb == other.max_size_kb &&
    allocated_size_kb == other.allocated_size_kb &&
    user_size_kb == other.user_size_kb &&
    free_space_kb == other.free_space_kb &&
    used_space_kb == other.used_space_kb &&
    used_percent_available == other.used_percent_available &&
    used_percent_allocated == other.used_percent_allocated &&
    datafiles == other.datafiles
end
allocation_type=(allocation_type) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] allocation_type Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 707
def allocation_type=(allocation_type)
  # rubocop:disable Style/ConditionalAssignment
  if allocation_type && !ALLOCATION_TYPE_ENUM.include?(allocation_type)
    OCI.logger.debug("Unknown value for 'allocation_type' [" + allocation_type + "]. Mapping to 'ALLOCATION_TYPE_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @allocation_type = ALLOCATION_TYPE_UNKNOWN_ENUM_VALUE
  else
    @allocation_type = allocation_type
  end
  # rubocop:enable Style/ConditionalAssignment
end
build_from_hash(attributes) click to toggle source

Builds the object from hash @param [Hash] attributes Model attributes in the form of hash @return [Object] Returns the model itself

# File lib/oci/database_management/models/tablespace_summary.rb, line 985
def build_from_hash(attributes)
  return nil unless attributes.is_a?(Hash)

  self.class.swagger_types.each_pair do |key, type|
    if type =~ /^Array<(.*)>/i
      # check to ensure the input is an array given that the the attribute
      # is documented as an array but the input is not
      if attributes[self.class.attribute_map[key]].is_a?(Array)
        public_method("#{key}=").call(
          attributes[self.class.attribute_map[key]]
            .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
        )
      end
    elsif !attributes[self.class.attribute_map[key]].nil?
      public_method("#{key}=").call(
        OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
      )
    end
    # or else data not found in attributes(hash), not an issue as the data can be optional
  end

  self
end
compress_for=(compress_for) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] compress_for Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 772
def compress_for=(compress_for)
  # rubocop:disable Style/ConditionalAssignment
  if compress_for && !COMPRESS_FOR_ENUM.include?(compress_for)
    OCI.logger.debug("Unknown value for 'compress_for' [" + compress_for + "]. Mapping to 'COMPRESS_FOR_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @compress_for = COMPRESS_FOR_UNKNOWN_ENUM_VALUE
  else
    @compress_for = compress_for
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_in_memory=(default_in_memory) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_in_memory Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 785
def default_in_memory=(default_in_memory)
  # rubocop:disable Style/ConditionalAssignment
  if default_in_memory && !DEFAULT_IN_MEMORY_ENUM.include?(default_in_memory)
    OCI.logger.debug("Unknown value for 'default_in_memory' [" + default_in_memory + "]. Mapping to 'DEFAULT_IN_MEMORY_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_in_memory = DEFAULT_IN_MEMORY_UNKNOWN_ENUM_VALUE
  else
    @default_in_memory = default_in_memory
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_in_memory_compression=(default_in_memory_compression) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_in_memory_compression Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 824
def default_in_memory_compression=(default_in_memory_compression)
  # rubocop:disable Style/ConditionalAssignment
  if default_in_memory_compression && !DEFAULT_IN_MEMORY_COMPRESSION_ENUM.include?(default_in_memory_compression)
    OCI.logger.debug("Unknown value for 'default_in_memory_compression' [" + default_in_memory_compression + "]. Mapping to 'DEFAULT_IN_MEMORY_COMPRESSION_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_in_memory_compression = DEFAULT_IN_MEMORY_COMPRESSION_UNKNOWN_ENUM_VALUE
  else
    @default_in_memory_compression = default_in_memory_compression
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_in_memory_distribute=(default_in_memory_distribute) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_in_memory_distribute Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 811
def default_in_memory_distribute=(default_in_memory_distribute)
  # rubocop:disable Style/ConditionalAssignment
  if default_in_memory_distribute && !DEFAULT_IN_MEMORY_DISTRIBUTE_ENUM.include?(default_in_memory_distribute)
    OCI.logger.debug("Unknown value for 'default_in_memory_distribute' [" + default_in_memory_distribute + "]. Mapping to 'DEFAULT_IN_MEMORY_DISTRIBUTE_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_in_memory_distribute = DEFAULT_IN_MEMORY_DISTRIBUTE_UNKNOWN_ENUM_VALUE
  else
    @default_in_memory_distribute = default_in_memory_distribute
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_in_memory_duplicate=(default_in_memory_duplicate) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_in_memory_duplicate Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 837
def default_in_memory_duplicate=(default_in_memory_duplicate)
  # rubocop:disable Style/ConditionalAssignment
  if default_in_memory_duplicate && !DEFAULT_IN_MEMORY_DUPLICATE_ENUM.include?(default_in_memory_duplicate)
    OCI.logger.debug("Unknown value for 'default_in_memory_duplicate' [" + default_in_memory_duplicate + "]. Mapping to 'DEFAULT_IN_MEMORY_DUPLICATE_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_in_memory_duplicate = DEFAULT_IN_MEMORY_DUPLICATE_UNKNOWN_ENUM_VALUE
  else
    @default_in_memory_duplicate = default_in_memory_duplicate
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_in_memory_priority=(default_in_memory_priority) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_in_memory_priority Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 798
def default_in_memory_priority=(default_in_memory_priority)
  # rubocop:disable Style/ConditionalAssignment
  if default_in_memory_priority && !DEFAULT_IN_MEMORY_PRIORITY_ENUM.include?(default_in_memory_priority)
    OCI.logger.debug("Unknown value for 'default_in_memory_priority' [" + default_in_memory_priority + "]. Mapping to 'DEFAULT_IN_MEMORY_PRIORITY_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_in_memory_priority = DEFAULT_IN_MEMORY_PRIORITY_UNKNOWN_ENUM_VALUE
  else
    @default_in_memory_priority = default_in_memory_priority
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_in_memory_service=(default_in_memory_service) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_in_memory_service Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 889
def default_in_memory_service=(default_in_memory_service)
  # rubocop:disable Style/ConditionalAssignment
  if default_in_memory_service && !DEFAULT_IN_MEMORY_SERVICE_ENUM.include?(default_in_memory_service)
    OCI.logger.debug("Unknown value for 'default_in_memory_service' [" + default_in_memory_service + "]. Mapping to 'DEFAULT_IN_MEMORY_SERVICE_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_in_memory_service = DEFAULT_IN_MEMORY_SERVICE_UNKNOWN_ENUM_VALUE
  else
    @default_in_memory_service = default_in_memory_service
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_index_compression=(default_index_compression) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_index_compression Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 863
def default_index_compression=(default_index_compression)
  # rubocop:disable Style/ConditionalAssignment
  if default_index_compression && !DEFAULT_INDEX_COMPRESSION_ENUM.include?(default_index_compression)
    OCI.logger.debug("Unknown value for 'default_index_compression' [" + default_index_compression + "]. Mapping to 'DEFAULT_INDEX_COMPRESSION_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_index_compression = DEFAULT_INDEX_COMPRESSION_UNKNOWN_ENUM_VALUE
  else
    @default_index_compression = default_index_compression
  end
  # rubocop:enable Style/ConditionalAssignment
end
default_table_compression=(default_table_compression) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] default_table_compression Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 733
def default_table_compression=(default_table_compression)
  # rubocop:disable Style/ConditionalAssignment
  if default_table_compression && !DEFAULT_TABLE_COMPRESSION_ENUM.include?(default_table_compression)
    OCI.logger.debug("Unknown value for 'default_table_compression' [" + default_table_compression + "]. Mapping to 'DEFAULT_TABLE_COMPRESSION_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @default_table_compression = DEFAULT_TABLE_COMPRESSION_UNKNOWN_ENUM_VALUE
  else
    @default_table_compression = default_table_compression
  end
  # rubocop:enable Style/ConditionalAssignment
end
eql?(other) click to toggle source

@see the `==` method @param [Object] other the other object to be compared

# File lib/oci/database_management/models/tablespace_summary.rb, line 965
def eql?(other)
  self == other
end
extent_management=(extent_management) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] extent_management Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 694
def extent_management=(extent_management)
  # rubocop:disable Style/ConditionalAssignment
  if extent_management && !EXTENT_MANAGEMENT_ENUM.include?(extent_management)
    OCI.logger.debug("Unknown value for 'extent_management' [" + extent_management + "]. Mapping to 'EXTENT_MANAGEMENT_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @extent_management = EXTENT_MANAGEMENT_UNKNOWN_ENUM_VALUE
  else
    @extent_management = extent_management
  end
  # rubocop:enable Style/ConditionalAssignment
end
hash() click to toggle source

Calculates hash code according to all attributes. @return [Fixnum] Hash code

# File lib/oci/database_management/models/tablespace_summary.rb, line 974
def hash
  [name, type, status, block_size_bytes, logging, is_force_logging, extent_management, allocation_type, is_plugged_in, segment_space_management, default_table_compression, retention, is_bigfile, predicate_evaluation, is_encrypted, compress_for, default_in_memory, default_in_memory_priority, default_in_memory_distribute, default_in_memory_compression, default_in_memory_duplicate, shared, default_index_compression, index_compress_for, default_cell_memory, default_in_memory_service, default_in_memory_service_name, lost_write_protect, is_chunk_tablespace, temp_group, max_size_kb, allocated_size_kb, user_size_kb, free_space_kb, used_space_kb, used_percent_available, used_percent_allocated, datafiles].hash
end
index_compress_for=(index_compress_for) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] index_compress_for Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 876
def index_compress_for=(index_compress_for)
  # rubocop:disable Style/ConditionalAssignment
  if index_compress_for && !INDEX_COMPRESS_FOR_ENUM.include?(index_compress_for)
    OCI.logger.debug("Unknown value for 'index_compress_for' [" + index_compress_for + "]. Mapping to 'INDEX_COMPRESS_FOR_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @index_compress_for = INDEX_COMPRESS_FOR_UNKNOWN_ENUM_VALUE
  else
    @index_compress_for = index_compress_for
  end
  # rubocop:enable Style/ConditionalAssignment
end
logging=(logging) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] logging Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 681
def logging=(logging)
  # rubocop:disable Style/ConditionalAssignment
  if logging && !LOGGING_ENUM.include?(logging)
    OCI.logger.debug("Unknown value for 'logging' [" + logging + "]. Mapping to 'LOGGING_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @logging = LOGGING_UNKNOWN_ENUM_VALUE
  else
    @logging = logging
  end
  # rubocop:enable Style/ConditionalAssignment
end
lost_write_protect=(lost_write_protect) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] lost_write_protect Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 902
def lost_write_protect=(lost_write_protect)
  # rubocop:disable Style/ConditionalAssignment
  if lost_write_protect && !LOST_WRITE_PROTECT_ENUM.include?(lost_write_protect)
    OCI.logger.debug("Unknown value for 'lost_write_protect' [" + lost_write_protect + "]. Mapping to 'LOST_WRITE_PROTECT_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @lost_write_protect = LOST_WRITE_PROTECT_UNKNOWN_ENUM_VALUE
  else
    @lost_write_protect = lost_write_protect
  end
  # rubocop:enable Style/ConditionalAssignment
end
predicate_evaluation=(predicate_evaluation) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] predicate_evaluation Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 759
def predicate_evaluation=(predicate_evaluation)
  # rubocop:disable Style/ConditionalAssignment
  if predicate_evaluation && !PREDICATE_EVALUATION_ENUM.include?(predicate_evaluation)
    OCI.logger.debug("Unknown value for 'predicate_evaluation' [" + predicate_evaluation + "]. Mapping to 'PREDICATE_EVALUATION_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @predicate_evaluation = PREDICATE_EVALUATION_UNKNOWN_ENUM_VALUE
  else
    @predicate_evaluation = predicate_evaluation
  end
  # rubocop:enable Style/ConditionalAssignment
end
retention=(retention) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] retention Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 746
def retention=(retention)
  # rubocop:disable Style/ConditionalAssignment
  if retention && !RETENTION_ENUM.include?(retention)
    OCI.logger.debug("Unknown value for 'retention' [" + retention + "]. Mapping to 'RETENTION_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @retention = RETENTION_UNKNOWN_ENUM_VALUE
  else
    @retention = retention
  end
  # rubocop:enable Style/ConditionalAssignment
end
segment_space_management=(segment_space_management) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] segment_space_management Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 720
def segment_space_management=(segment_space_management)
  # rubocop:disable Style/ConditionalAssignment
  if segment_space_management && !SEGMENT_SPACE_MANAGEMENT_ENUM.include?(segment_space_management)
    OCI.logger.debug("Unknown value for 'segment_space_management' [" + segment_space_management + "]. Mapping to 'SEGMENT_SPACE_MANAGEMENT_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @segment_space_management = SEGMENT_SPACE_MANAGEMENT_UNKNOWN_ENUM_VALUE
  else
    @segment_space_management = segment_space_management
  end
  # rubocop:enable Style/ConditionalAssignment
end
shared=(shared) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] shared Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 850
def shared=(shared)
  # rubocop:disable Style/ConditionalAssignment
  if shared && !SHARED_ENUM.include?(shared)
    OCI.logger.debug("Unknown value for 'shared' [" + shared + "]. Mapping to 'SHARED_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @shared = SHARED_UNKNOWN_ENUM_VALUE
  else
    @shared = shared
  end
  # rubocop:enable Style/ConditionalAssignment
end
status=(status) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] status Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 668
def status=(status)
  # rubocop:disable Style/ConditionalAssignment
  if status && !STATUS_ENUM.include?(status)
    OCI.logger.debug("Unknown value for 'status' [" + status + "]. Mapping to 'STATUS_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @status = STATUS_UNKNOWN_ENUM_VALUE
  else
    @status = status
  end
  # rubocop:enable Style/ConditionalAssignment
end
to_hash() click to toggle source

Returns the object in the form of hash @return [Hash] Returns the object in the form of hash

# File lib/oci/database_management/models/tablespace_summary.rb, line 1018
def to_hash
  hash = {}
  self.class.attribute_map.each_pair do |attr, param|
    value = public_method(attr).call
    next if value.nil? && !instance_variable_defined?("@#{attr}")

    hash[param] = _to_hash(value)
  end
  hash
end
to_s() click to toggle source

Returns the string representation of the object @return [String] String presentation of the object

# File lib/oci/database_management/models/tablespace_summary.rb, line 1012
def to_s
  to_hash.to_s
end
type=(type) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] type Object to be assigned

# File lib/oci/database_management/models/tablespace_summary.rb, line 655
def type=(type)
  # rubocop:disable Style/ConditionalAssignment
  if type && !TYPE_ENUM.include?(type)
    OCI.logger.debug("Unknown value for 'type' [" + type + "]. Mapping to 'TYPE_UNKNOWN_ENUM_VALUE'") if OCI.logger
    @type = TYPE_UNKNOWN_ENUM_VALUE
  else
    @type = type
  end
  # rubocop:enable Style/ConditionalAssignment
end

Private Instance Methods

_to_hash(value) click to toggle source

Outputs non-array value in the form of hash For object, use to_hash. Otherwise, just return the value @param [Object] value Any valid value @return [Hash] Returns the value in the form of hash

# File lib/oci/database_management/models/tablespace_summary.rb, line 1035
def _to_hash(value)
  if value.is_a?(Array)
    value.compact.map { |v| _to_hash(v) }
  elsif value.is_a?(Hash)
    {}.tap do |hash|
      value.each { |k, v| hash[k] = _to_hash(v) }
    end
  elsif value.respond_to? :to_hash
    value.to_hash
  else
    value
  end
end