312 lines
11 KiB
PHP
312 lines
11 KiB
PHP
|
<?php
|
||
|
|
/*
|
||
|
|
* Copyright 2014 Google Inc.
|
||
|
|
*
|
||
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
||
|
|
* use this file except in compliance with the License. You may obtain a copy of
|
||
|
|
* the License at
|
||
|
|
*
|
||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||
|
|
*
|
||
|
|
* Unless required by applicable law or agreed to in writing, software
|
||
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||
|
|
* License for the specific language governing permissions and limitations under
|
||
|
|
* the License.
|
||
|
|
*/
|
||
|
|
|
||
|
|
namespace Google\Service\BigtableAdmin;
|
||
|
|
|
||
|
|
class Table extends \Google\Model
|
||
|
|
{
|
||
|
|
/**
|
||
|
|
* The user did not specify a granularity. Should not be returned. When
|
||
|
|
* specified during table creation, MILLIS will be used.
|
||
|
|
*/
|
||
|
|
public const GRANULARITY_TIMESTAMP_GRANULARITY_UNSPECIFIED = 'TIMESTAMP_GRANULARITY_UNSPECIFIED';
|
||
|
|
/**
|
||
|
|
* The table keeps data versioned at a granularity of 1ms.
|
||
|
|
*/
|
||
|
|
public const GRANULARITY_MILLIS = 'MILLIS';
|
||
|
|
protected $automatedBackupPolicyType = AutomatedBackupPolicy::class;
|
||
|
|
protected $automatedBackupPolicyDataType = '';
|
||
|
|
protected $changeStreamConfigType = ChangeStreamConfig::class;
|
||
|
|
protected $changeStreamConfigDataType = '';
|
||
|
|
protected $clusterStatesType = ClusterState::class;
|
||
|
|
protected $clusterStatesDataType = 'map';
|
||
|
|
protected $columnFamiliesType = ColumnFamily::class;
|
||
|
|
protected $columnFamiliesDataType = 'map';
|
||
|
|
/**
|
||
|
|
* Set to true to make the table protected against data loss. i.e. deleting
|
||
|
|
* the following resources through Admin APIs are prohibited: * The table. *
|
||
|
|
* The column families in the table. * The instance containing the table. Note
|
||
|
|
* one can still delete the data stored in the table through Data APIs.
|
||
|
|
*
|
||
|
|
* @var bool
|
||
|
|
*/
|
||
|
|
public $deletionProtection;
|
||
|
|
/**
|
||
|
|
* Immutable. The granularity at which timestamps are stored in this table.
|
||
|
|
* Timestamps not matching the granularity will be rejected. If unspecified at
|
||
|
|
* creation time, the value will be set to `MILLIS`. Views: `SCHEMA_VIEW`,
|
||
|
|
* `FULL`.
|
||
|
|
*
|
||
|
|
* @var string
|
||
|
|
*/
|
||
|
|
public $granularity;
|
||
|
|
/**
|
||
|
|
* The unique name of the table. Values are of the form
|
||
|
|
* `projects/{project}/instances/{instance}/tables/_a-zA-Z0-9*`. Views:
|
||
|
|
* `NAME_ONLY`, `SCHEMA_VIEW`, `REPLICATION_VIEW`, `STATS_VIEW`, `FULL`
|
||
|
|
*
|
||
|
|
* @var string
|
||
|
|
*/
|
||
|
|
public $name;
|
||
|
|
protected $restoreInfoType = RestoreInfo::class;
|
||
|
|
protected $restoreInfoDataType = '';
|
||
|
|
protected $rowKeySchemaType = GoogleBigtableAdminV2TypeStruct::class;
|
||
|
|
protected $rowKeySchemaDataType = '';
|
||
|
|
protected $statsType = TableStats::class;
|
||
|
|
protected $statsDataType = '';
|
||
|
|
protected $tieredStorageConfigType = TieredStorageConfig::class;
|
||
|
|
protected $tieredStorageConfigDataType = '';
|
||
|
|
|
||
|
|
/**
|
||
|
|
* If specified, automated backups are enabled for this table. Otherwise,
|
||
|
|
* automated backups are disabled.
|
||
|
|
*
|
||
|
|
* @param AutomatedBackupPolicy $automatedBackupPolicy
|
||
|
|
*/
|
||
|
|
public function setAutomatedBackupPolicy(AutomatedBackupPolicy $automatedBackupPolicy)
|
||
|
|
{
|
||
|
|
$this->automatedBackupPolicy = $automatedBackupPolicy;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return AutomatedBackupPolicy
|
||
|
|
*/
|
||
|
|
public function getAutomatedBackupPolicy()
|
||
|
|
{
|
||
|
|
return $this->automatedBackupPolicy;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* If specified, enable the change stream on this table. Otherwise, the change
|
||
|
|
* stream is disabled and the change stream is not retained.
|
||
|
|
*
|
||
|
|
* @param ChangeStreamConfig $changeStreamConfig
|
||
|
|
*/
|
||
|
|
public function setChangeStreamConfig(ChangeStreamConfig $changeStreamConfig)
|
||
|
|
{
|
||
|
|
$this->changeStreamConfig = $changeStreamConfig;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return ChangeStreamConfig
|
||
|
|
*/
|
||
|
|
public function getChangeStreamConfig()
|
||
|
|
{
|
||
|
|
return $this->changeStreamConfig;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Output only. Map from cluster ID to per-cluster table state. If it could
|
||
|
|
* not be determined whether or not the table has data in a particular cluster
|
||
|
|
* (for example, if its zone is unavailable), then there will be an entry for
|
||
|
|
* the cluster with UNKNOWN `replication_status`. Views: `REPLICATION_VIEW`,
|
||
|
|
* `ENCRYPTION_VIEW`, `FULL`
|
||
|
|
*
|
||
|
|
* @param ClusterState[] $clusterStates
|
||
|
|
*/
|
||
|
|
public function setClusterStates($clusterStates)
|
||
|
|
{
|
||
|
|
$this->clusterStates = $clusterStates;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return ClusterState[]
|
||
|
|
*/
|
||
|
|
public function getClusterStates()
|
||
|
|
{
|
||
|
|
return $this->clusterStates;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The column families configured for this table, mapped by column family ID.
|
||
|
|
* Views: `SCHEMA_VIEW`, `STATS_VIEW`, `FULL`
|
||
|
|
*
|
||
|
|
* @param ColumnFamily[] $columnFamilies
|
||
|
|
*/
|
||
|
|
public function setColumnFamilies($columnFamilies)
|
||
|
|
{
|
||
|
|
$this->columnFamilies = $columnFamilies;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return ColumnFamily[]
|
||
|
|
*/
|
||
|
|
public function getColumnFamilies()
|
||
|
|
{
|
||
|
|
return $this->columnFamilies;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Set to true to make the table protected against data loss. i.e. deleting
|
||
|
|
* the following resources through Admin APIs are prohibited: * The table. *
|
||
|
|
* The column families in the table. * The instance containing the table. Note
|
||
|
|
* one can still delete the data stored in the table through Data APIs.
|
||
|
|
*
|
||
|
|
* @param bool $deletionProtection
|
||
|
|
*/
|
||
|
|
public function setDeletionProtection($deletionProtection)
|
||
|
|
{
|
||
|
|
$this->deletionProtection = $deletionProtection;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return bool
|
||
|
|
*/
|
||
|
|
public function getDeletionProtection()
|
||
|
|
{
|
||
|
|
return $this->deletionProtection;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Immutable. The granularity at which timestamps are stored in this table.
|
||
|
|
* Timestamps not matching the granularity will be rejected. If unspecified at
|
||
|
|
* creation time, the value will be set to `MILLIS`. Views: `SCHEMA_VIEW`,
|
||
|
|
* `FULL`.
|
||
|
|
*
|
||
|
|
* Accepted values: TIMESTAMP_GRANULARITY_UNSPECIFIED, MILLIS
|
||
|
|
*
|
||
|
|
* @param self::GRANULARITY_* $granularity
|
||
|
|
*/
|
||
|
|
public function setGranularity($granularity)
|
||
|
|
{
|
||
|
|
$this->granularity = $granularity;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return self::GRANULARITY_*
|
||
|
|
*/
|
||
|
|
public function getGranularity()
|
||
|
|
{
|
||
|
|
return $this->granularity;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The unique name of the table. Values are of the form
|
||
|
|
* `projects/{project}/instances/{instance}/tables/_a-zA-Z0-9*`. Views:
|
||
|
|
* `NAME_ONLY`, `SCHEMA_VIEW`, `REPLICATION_VIEW`, `STATS_VIEW`, `FULL`
|
||
|
|
*
|
||
|
|
* @param string $name
|
||
|
|
*/
|
||
|
|
public function setName($name)
|
||
|
|
{
|
||
|
|
$this->name = $name;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return string
|
||
|
|
*/
|
||
|
|
public function getName()
|
||
|
|
{
|
||
|
|
return $this->name;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Output only. If this table was restored from another data source (e.g. a
|
||
|
|
* backup), this field will be populated with information about the restore.
|
||
|
|
*
|
||
|
|
* @param RestoreInfo $restoreInfo
|
||
|
|
*/
|
||
|
|
public function setRestoreInfo(RestoreInfo $restoreInfo)
|
||
|
|
{
|
||
|
|
$this->restoreInfo = $restoreInfo;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return RestoreInfo
|
||
|
|
*/
|
||
|
|
public function getRestoreInfo()
|
||
|
|
{
|
||
|
|
return $this->restoreInfo;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* The row key schema for this table. The schema is used to decode the raw row
|
||
|
|
* key bytes into a structured format. The order of field declarations in this
|
||
|
|
* schema is important, as it reflects how the raw row key bytes are
|
||
|
|
* structured. Currently, this only affects how the key is read via a
|
||
|
|
* GoogleSQL query from the ExecuteQuery API. For a SQL query, the _key column
|
||
|
|
* is still read as raw bytes. But queries can reference the key fields by
|
||
|
|
* name, which will be decoded from _key using provided type and encoding.
|
||
|
|
* Queries that reference key fields will fail if they encounter an invalid
|
||
|
|
* row key. For example, if _key = "some_id#2024-04-30#\x00\x13\x00\xf3" with
|
||
|
|
* the following schema: { fields { field_name: "id" type { string { encoding:
|
||
|
|
* utf8_bytes {} } } } fields { field_name: "date" type { string { encoding:
|
||
|
|
* utf8_bytes {} } } } fields { field_name: "product_code" type { int64 {
|
||
|
|
* encoding: big_endian_bytes {} } } } encoding { delimited_bytes { delimiter:
|
||
|
|
* "#" } } } The decoded key parts would be: id = "some_id", date =
|
||
|
|
* "2024-04-30", product_code = 1245427 The query "SELECT _key, product_code
|
||
|
|
* FROM table" will return two columns:
|
||
|
|
* /------------------------------------------------------\ | _key |
|
||
|
|
* product_code | | --------------------------------------|--------------| |
|
||
|
|
* "some_id#2024-04-30#\x00\x13\x00\xf3" | 1245427 |
|
||
|
|
* \------------------------------------------------------/ The schema has the
|
||
|
|
* following invariants: (1) The decoded field values are order-preserved. For
|
||
|
|
* read, the field values will be decoded in sorted mode from the raw bytes.
|
||
|
|
* (2) Every field in the schema must specify a non-empty name. (3) Every
|
||
|
|
* field must specify a type with an associated encoding. The type is limited
|
||
|
|
* to scalar types only: Array, Map, Aggregate, and Struct are not allowed.
|
||
|
|
* (4) The field names must not collide with existing column family names and
|
||
|
|
* reserved keywords "_key" and "_timestamp". The following update operations
|
||
|
|
* are allowed for row_key_schema: - Update from an empty schema to a new
|
||
|
|
* schema. - Remove the existing schema. This operation requires setting the
|
||
|
|
* `ignore_warnings` flag to `true`, since it might be a backward incompatible
|
||
|
|
* change. Without the flag, the update request will fail with an
|
||
|
|
* INVALID_ARGUMENT error. Any other row key schema update operation (e.g.
|
||
|
|
* update existing schema columns names or types) is currently unsupported.
|
||
|
|
*
|
||
|
|
* @param GoogleBigtableAdminV2TypeStruct $rowKeySchema
|
||
|
|
*/
|
||
|
|
public function setRowKeySchema(GoogleBigtableAdminV2TypeStruct $rowKeySchema)
|
||
|
|
{
|
||
|
|
$this->rowKeySchema = $rowKeySchema;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return GoogleBigtableAdminV2TypeStruct
|
||
|
|
*/
|
||
|
|
public function getRowKeySchema()
|
||
|
|
{
|
||
|
|
return $this->rowKeySchema;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Output only. Only available with STATS_VIEW, this includes summary
|
||
|
|
* statistics about the entire table contents. For statistics about a specific
|
||
|
|
* column family, see ColumnFamilyStats in the mapped ColumnFamily collection
|
||
|
|
* above.
|
||
|
|
*
|
||
|
|
* @param TableStats $stats
|
||
|
|
*/
|
||
|
|
public function setStats(TableStats $stats)
|
||
|
|
{
|
||
|
|
$this->stats = $stats;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return TableStats
|
||
|
|
*/
|
||
|
|
public function getStats()
|
||
|
|
{
|
||
|
|
return $this->stats;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Rules to specify what data is stored in each storage tier. Different tiers
|
||
|
|
* store data differently, providing different trade-offs between cost and
|
||
|
|
* performance. Different parts of a table can be stored separately on
|
||
|
|
* different tiers. If a config is specified, tiered storage is enabled for
|
||
|
|
* this table. Otherwise, tiered storage is disabled. Only SSD instances can
|
||
|
|
* configure tiered storage.
|
||
|
|
*
|
||
|
|
* @param TieredStorageConfig $tieredStorageConfig
|
||
|
|
*/
|
||
|
|
public function setTieredStorageConfig(TieredStorageConfig $tieredStorageConfig)
|
||
|
|
{
|
||
|
|
$this->tieredStorageConfig = $tieredStorageConfig;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @return TieredStorageConfig
|
||
|
|
*/
|
||
|
|
public function getTieredStorageConfig()
|
||
|
|
{
|
||
|
|
return $this->tieredStorageConfig;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Adding a class alias for backwards compatibility with the previous class name.
|
||
|
|
class_alias(Table::class, 'Google_Service_BigtableAdmin_Table');
|