class OCI::DatabaseManagement::Models::Tablespace

The details 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.rb, line 288
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.rb, line 423
def initialize(attributes = {})
  return unless attributes.is_a?(Hash)

  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.rb, line 334
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.rb, line 794
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.rb, line 663
def allocation_type=(allocation_type)
  raise "Invalid value for 'allocation_type': this must be one of the values in ALLOCATION_TYPE_ENUM." if allocation_type && !ALLOCATION_TYPE_ENUM.include?(allocation_type)

  @allocation_type = allocation_type
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.rb, line 861
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.rb, line 703
def compress_for=(compress_for)
  raise "Invalid value for 'compress_for': this must be one of the values in COMPRESS_FOR_ENUM." if compress_for && !COMPRESS_FOR_ENUM.include?(compress_for)

  @compress_for = compress_for
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.rb, line 711
def default_in_memory=(default_in_memory)
  raise "Invalid value for 'default_in_memory': this must be one of the values in DEFAULT_IN_MEMORY_ENUM." if default_in_memory && !DEFAULT_IN_MEMORY_ENUM.include?(default_in_memory)

  @default_in_memory = default_in_memory
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.rb, line 735
def default_in_memory_compression=(default_in_memory_compression)
  raise "Invalid value for 'default_in_memory_compression': this must be one of the values in DEFAULT_IN_MEMORY_COMPRESSION_ENUM." if default_in_memory_compression && !DEFAULT_IN_MEMORY_COMPRESSION_ENUM.include?(default_in_memory_compression)

  @default_in_memory_compression = default_in_memory_compression
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.rb, line 727
def default_in_memory_distribute=(default_in_memory_distribute)
  raise "Invalid value for 'default_in_memory_distribute': this must be one of the values in DEFAULT_IN_MEMORY_DISTRIBUTE_ENUM." if default_in_memory_distribute && !DEFAULT_IN_MEMORY_DISTRIBUTE_ENUM.include?(default_in_memory_distribute)

  @default_in_memory_distribute = default_in_memory_distribute
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.rb, line 743
def default_in_memory_duplicate=(default_in_memory_duplicate)
  raise "Invalid value for 'default_in_memory_duplicate': this must be one of the values in DEFAULT_IN_MEMORY_DUPLICATE_ENUM." if default_in_memory_duplicate && !DEFAULT_IN_MEMORY_DUPLICATE_ENUM.include?(default_in_memory_duplicate)

  @default_in_memory_duplicate = default_in_memory_duplicate
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.rb, line 719
def default_in_memory_priority=(default_in_memory_priority)
  raise "Invalid value for 'default_in_memory_priority': this must be one of the values in DEFAULT_IN_MEMORY_PRIORITY_ENUM." if default_in_memory_priority && !DEFAULT_IN_MEMORY_PRIORITY_ENUM.include?(default_in_memory_priority)

  @default_in_memory_priority = default_in_memory_priority
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.rb, line 775
def default_in_memory_service=(default_in_memory_service)
  raise "Invalid value for 'default_in_memory_service': this must be one of the values in DEFAULT_IN_MEMORY_SERVICE_ENUM." if default_in_memory_service && !DEFAULT_IN_MEMORY_SERVICE_ENUM.include?(default_in_memory_service)

  @default_in_memory_service = default_in_memory_service
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.rb, line 759
def default_index_compression=(default_index_compression)
  raise "Invalid value for 'default_index_compression': this must be one of the values in DEFAULT_INDEX_COMPRESSION_ENUM." if default_index_compression && !DEFAULT_INDEX_COMPRESSION_ENUM.include?(default_index_compression)

  @default_index_compression = default_index_compression
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.rb, line 679
def default_table_compression=(default_table_compression)
  raise "Invalid value for 'default_table_compression': this must be one of the values in DEFAULT_TABLE_COMPRESSION_ENUM." if default_table_compression && !DEFAULT_TABLE_COMPRESSION_ENUM.include?(default_table_compression)

  @default_table_compression = default_table_compression
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.rb, line 841
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.rb, line 655
def extent_management=(extent_management)
  raise "Invalid value for 'extent_management': this must be one of the values in EXTENT_MANAGEMENT_ENUM." if extent_management && !EXTENT_MANAGEMENT_ENUM.include?(extent_management)

  @extent_management = extent_management
end
hash() click to toggle source

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

# File lib/oci/database_management/models/tablespace.rb, line 850
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.rb, line 767
def index_compress_for=(index_compress_for)
  raise "Invalid value for 'index_compress_for': this must be one of the values in INDEX_COMPRESS_FOR_ENUM." if index_compress_for && !INDEX_COMPRESS_FOR_ENUM.include?(index_compress_for)

  @index_compress_for = index_compress_for
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.rb, line 647
def logging=(logging)
  raise "Invalid value for 'logging': this must be one of the values in LOGGING_ENUM." if logging && !LOGGING_ENUM.include?(logging)

  @logging = logging
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.rb, line 783
def lost_write_protect=(lost_write_protect)
  raise "Invalid value for 'lost_write_protect': this must be one of the values in LOST_WRITE_PROTECT_ENUM." if lost_write_protect && !LOST_WRITE_PROTECT_ENUM.include?(lost_write_protect)

  @lost_write_protect = lost_write_protect
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.rb, line 695
def predicate_evaluation=(predicate_evaluation)
  raise "Invalid value for 'predicate_evaluation': this must be one of the values in PREDICATE_EVALUATION_ENUM." if predicate_evaluation && !PREDICATE_EVALUATION_ENUM.include?(predicate_evaluation)

  @predicate_evaluation = predicate_evaluation
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.rb, line 687
def retention=(retention)
  raise "Invalid value for 'retention': this must be one of the values in RETENTION_ENUM." if retention && !RETENTION_ENUM.include?(retention)

  @retention = retention
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.rb, line 671
def segment_space_management=(segment_space_management)
  raise "Invalid value for 'segment_space_management': this must be one of the values in SEGMENT_SPACE_MANAGEMENT_ENUM." if segment_space_management && !SEGMENT_SPACE_MANAGEMENT_ENUM.include?(segment_space_management)

  @segment_space_management = segment_space_management
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.rb, line 751
def shared=(shared)
  raise "Invalid value for 'shared': this must be one of the values in SHARED_ENUM." if shared && !SHARED_ENUM.include?(shared)

  @shared = shared
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.rb, line 639
def status=(status)
  raise "Invalid value for 'status': this must be one of the values in STATUS_ENUM." if status && !STATUS_ENUM.include?(status)

  @status = status
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.rb, line 894
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.rb, line 888
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.rb, line 631
def type=(type)
  raise "Invalid value for 'type': this must be one of the values in TYPE_ENUM." if type && !TYPE_ENUM.include?(type)

  @type = type
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.rb, line 911
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