From df853413fdb648ab90e0eec6c7f0656b335fe76e Mon Sep 17 00:00:00 2001 From: sumeetgajjar Date: Fri, 28 Apr 2023 17:39:32 -0700 Subject: [PATCH] chore: Add missing storage related fields to Table, TableInfo and StandardTableDefinition --- .../bigquery/StandardTableDefinition.java | 105 +++++++++++ .../java/com/google/cloud/bigquery/Table.java | 42 +++++ .../com/google/cloud/bigquery/TableInfo.java | 168 ++++++++++++++++++ .../bigquery/StandardTableDefinitionTest.java | 35 ++++ .../google/cloud/bigquery/TableInfoTest.java | 35 ++++ .../cloud/bigquery/it/ITBigQueryTest.java | 17 ++ 6 files changed, 402 insertions(+) diff --git a/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/StandardTableDefinition.java b/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/StandardTableDefinition.java index 4b09fe3c40..6eb53ec011 100644 --- a/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/StandardTableDefinition.java +++ b/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/StandardTableDefinition.java @@ -132,6 +132,20 @@ public abstract static class Builder public abstract Builder setNumLongTermBytes(Long numLongTermBytes); + public abstract Builder setNumTimeTravelPhysicalBytes(Long numTimeTravelPhysicalBytes); + + public abstract Builder setNumTotalLogicalBytes(Long numTotalLogicalBytes); + + public abstract Builder setNumActiveLogicalBytes(Long numActiveLogicalBytes); + + public abstract Builder setNumLongTermLogicalBytes(Long numLongTermLogicalBytes); + + public abstract Builder setNumTotalPhysicalBytes(Long numTotalPhysicalBytes); + + public abstract Builder setNumActivePhysicalBytes(Long numActivePhysicalBytes); + + public abstract Builder setNumLongTermPhysicalBytes(Long numLongTermPhysicalBytes); + public abstract Builder setNumRows(Long numRows); public abstract Builder setLocation(String location); @@ -178,6 +192,69 @@ public abstract static class Builder @Nullable public abstract Long getNumLongTermBytes(); + /** + * Returns the number of time travel physical bytes. + * + * @see Storage + * Pricing + */ + @Nullable + public abstract Long getNumTimeTravelPhysicalBytes(); + + /** + * Returns the number of total logical bytes. + * + * @see Storage + * Pricing + */ + @Nullable + public abstract Long getNumTotalLogicalBytes(); + + /** + * Returns the number of active logical bytes. + * + * @see Storage + * Pricing + */ + @Nullable + public abstract Long getNumActiveLogicalBytes(); + + /** + * Returns the number of long term logical bytes. + * + * @see Storage + * Pricing + */ + @Nullable + public abstract Long getNumLongTermLogicalBytes(); + + /** + * Returns the number of total physical bytes. + * + * @see Storage + * Pricing + */ + @Nullable + public abstract Long getNumTotalPhysicalBytes(); + + /** + * Returns the number of active physical bytes. + * + * @see Storage + * Pricing + */ + @Nullable + public abstract Long getNumActivePhysicalBytes(); + + /** + * Returns the number of long term physical bytes. + * + * @see Storage + * Pricing + */ + @Nullable + public abstract Long getNumLongTermPhysicalBytes(); + /** Returns the number of rows in this table, excluding any data in the streaming buffer. */ @Nullable public abstract Long getNumRows(); @@ -246,6 +323,13 @@ Table toPb() { } tablePb.setNumBytes(getNumBytes()); tablePb.setNumLongTermBytes(getNumLongTermBytes()); + tablePb.setNumTimeTravelPhysicalBytes(getNumTimeTravelPhysicalBytes()); + tablePb.setNumTotalLogicalBytes(getNumTotalLogicalBytes()); + tablePb.setNumActiveLogicalBytes(getNumActiveLogicalBytes()); + tablePb.setNumLongTermLogicalBytes(getNumLongTermLogicalBytes()); + tablePb.setNumTotalPhysicalBytes(getNumTotalPhysicalBytes()); + tablePb.setNumActivePhysicalBytes(getNumActivePhysicalBytes()); + tablePb.setNumLongTermPhysicalBytes(getNumLongTermPhysicalBytes()); tablePb.setLocation(getLocation()); if (getStreamingBuffer() != null) { tablePb.setStreamingBuffer(getStreamingBuffer().toPb()); @@ -296,6 +380,27 @@ static StandardTableDefinition fromPb(Table tablePb) { if (tablePb.getNumLongTermBytes() != null) { builder.setNumLongTermBytes(tablePb.getNumLongTermBytes()); } + if (tablePb.getNumTimeTravelPhysicalBytes() != null) { + builder.setNumTimeTravelPhysicalBytes(tablePb.getNumTimeTravelPhysicalBytes()); + } + if (tablePb.getNumTotalLogicalBytes() != null) { + builder.setNumTotalLogicalBytes(tablePb.getNumTotalLogicalBytes()); + } + if (tablePb.getNumActiveLogicalBytes() != null) { + builder.setNumActiveLogicalBytes(tablePb.getNumActiveLogicalBytes()); + } + if (tablePb.getNumLongTermLogicalBytes() != null) { + builder.setNumLongTermLogicalBytes(tablePb.getNumLongTermLogicalBytes()); + } + if (tablePb.getNumTotalPhysicalBytes() != null) { + builder.setNumTotalPhysicalBytes(tablePb.getNumTotalPhysicalBytes()); + } + if (tablePb.getNumActivePhysicalBytes() != null) { + builder.setNumActivePhysicalBytes(tablePb.getNumActivePhysicalBytes()); + } + if (tablePb.getNumLongTermPhysicalBytes() != null) { + builder.setNumLongTermPhysicalBytes(tablePb.getNumLongTermPhysicalBytes()); + } return builder.setNumBytes(tablePb.getNumBytes()).setLocation(tablePb.getLocation()).build(); } } diff --git a/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/Table.java b/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/Table.java index 3e67e8d750..5e041108f0 100644 --- a/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/Table.java +++ b/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/Table.java @@ -114,6 +114,48 @@ Builder setNumLongTermBytes(Long numLongTermBytes) { return this; } + @Override + Builder setNumTimeTravelPhysicalBytes(Long numTimeTravelPhysicalBytes) { + infoBuilder.setNumTimeTravelPhysicalBytes(numTimeTravelPhysicalBytes); + return this; + } + + @Override + Builder setNumTotalLogicalBytes(Long numTotalLogicalBytes) { + infoBuilder.setNumTotalLogicalBytes(numTotalLogicalBytes); + return this; + } + + @Override + Builder setNumActiveLogicalBytes(Long numActiveLogicalBytes) { + infoBuilder.setNumActiveLogicalBytes(numActiveLogicalBytes); + return this; + } + + @Override + Builder setNumLongTermLogicalBytes(Long numLongTermLogicalBytes) { + infoBuilder.setNumLongTermLogicalBytes(numLongTermLogicalBytes); + return this; + } + + @Override + Builder setNumTotalPhysicalBytes(Long numTotalPhysicalBytes) { + infoBuilder.setNumTotalPhysicalBytes(numTotalPhysicalBytes); + return this; + } + + @Override + Builder setNumActivePhysicalBytes(Long numActivePhysicalBytes) { + infoBuilder.setNumActivePhysicalBytes(numActivePhysicalBytes); + return this; + } + + @Override + Builder setNumLongTermPhysicalBytes(Long numLongTermPhysicalBytes) { + infoBuilder.setNumLongTermPhysicalBytes(numLongTermPhysicalBytes); + return this; + } + @Override Builder setNumRows(BigInteger numRows) { infoBuilder.setNumRows(numRows); diff --git a/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/TableInfo.java b/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/TableInfo.java index 19e9de2b79..a9fd9fd94f 100644 --- a/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/TableInfo.java +++ b/google-cloud-bigquery/src/main/java/com/google/cloud/bigquery/TableInfo.java @@ -67,6 +67,13 @@ public Table apply(TableInfo tableInfo) { private final Long lastModifiedTime; private final Long numBytes; private final Long numLongTermBytes; + private final Long numTimeTravelPhysicalBytes; + private final Long numTotalLogicalBytes; + private final Long numActiveLogicalBytes; + private final Long numLongTermLogicalBytes; + private final Long numTotalPhysicalBytes; + private final Long numActivePhysicalBytes; + private final Long numLongTermPhysicalBytes; private final BigInteger numRows; private final TableDefinition definition; private final EncryptionConfiguration encryptionConfiguration; @@ -103,6 +110,20 @@ public abstract static class Builder { abstract Builder setNumLongTermBytes(Long numLongTermBytes); + abstract Builder setNumTimeTravelPhysicalBytes(Long numTimeTravelPhysicalBytes); + + abstract Builder setNumTotalLogicalBytes(Long numTotalLogicalBytes); + + abstract Builder setNumActiveLogicalBytes(Long numActiveLogicalBytes); + + abstract Builder setNumLongTermLogicalBytes(Long numLongTermLogicalBytes); + + abstract Builder setNumTotalPhysicalBytes(Long numTotalPhysicalBytes); + + abstract Builder setNumActivePhysicalBytes(Long numActivePhysicalBytes); + + abstract Builder setNumLongTermPhysicalBytes(Long numLongTermPhysicalBytes); + abstract Builder setNumRows(BigInteger numRows); abstract Builder setSelfLink(String selfLink); @@ -157,6 +178,13 @@ static class BuilderImpl extends Builder { private Long lastModifiedTime; private Long numBytes; private Long numLongTermBytes; + private Long numTimeTravelPhysicalBytes; + private Long numTotalLogicalBytes; + private Long numActiveLogicalBytes; + private Long numLongTermLogicalBytes; + private Long numTotalPhysicalBytes; + private Long numActivePhysicalBytes; + private Long numLongTermPhysicalBytes; private BigInteger numRows; private TableDefinition definition; private EncryptionConfiguration encryptionConfiguration; @@ -179,6 +207,13 @@ static class BuilderImpl extends Builder { this.lastModifiedTime = tableInfo.lastModifiedTime; this.numBytes = tableInfo.numBytes; this.numLongTermBytes = tableInfo.numLongTermBytes; + this.numTimeTravelPhysicalBytes = tableInfo.numTimeTravelPhysicalBytes; + this.numTotalLogicalBytes = tableInfo.numTotalLogicalBytes; + this.numActiveLogicalBytes = tableInfo.numActiveLogicalBytes; + this.numLongTermLogicalBytes = tableInfo.numLongTermLogicalBytes; + this.numTotalPhysicalBytes = tableInfo.numTotalPhysicalBytes; + this.numActivePhysicalBytes = tableInfo.numActivePhysicalBytes; + this.numLongTermPhysicalBytes = tableInfo.numLongTermPhysicalBytes; this.numRows = tableInfo.numRows; this.definition = tableInfo.definition; this.encryptionConfiguration = tableInfo.encryptionConfiguration; @@ -202,6 +237,13 @@ static class BuilderImpl extends Builder { this.selfLink = tablePb.getSelfLink(); this.numBytes = tablePb.getNumBytes(); this.numLongTermBytes = tablePb.getNumLongTermBytes(); + this.numTimeTravelPhysicalBytes = tablePb.getNumTimeTravelPhysicalBytes(); + this.numTotalLogicalBytes = tablePb.getNumTotalLogicalBytes(); + this.numActiveLogicalBytes = tablePb.getNumActiveLogicalBytes(); + this.numLongTermLogicalBytes = tablePb.getNumLongTermLogicalBytes(); + this.numTotalPhysicalBytes = tablePb.getNumTotalPhysicalBytes(); + this.numActivePhysicalBytes = tablePb.getNumActivePhysicalBytes(); + this.numLongTermPhysicalBytes = tablePb.getNumLongTermPhysicalBytes(); this.numRows = tablePb.getNumRows(); this.definition = TableDefinition.fromPb(tablePb); if (tablePb.getEncryptionConfiguration() != null) { @@ -270,6 +312,48 @@ Builder setNumLongTermBytes(Long numLongTermBytes) { return this; } + @Override + Builder setNumTimeTravelPhysicalBytes(Long numTimeTravelPhysicalBytes) { + this.numTimeTravelPhysicalBytes = numTimeTravelPhysicalBytes; + return this; + } + + @Override + Builder setNumTotalLogicalBytes(Long numTotalLogicalBytes) { + this.numTotalLogicalBytes = numTotalLogicalBytes; + return this; + } + + @Override + Builder setNumActiveLogicalBytes(Long numActiveLogicalBytes) { + this.numActiveLogicalBytes = numActiveLogicalBytes; + return this; + } + + @Override + Builder setNumLongTermLogicalBytes(Long numLongTermLogicalBytes) { + this.numLongTermLogicalBytes = numLongTermLogicalBytes; + return this; + } + + @Override + Builder setNumTotalPhysicalBytes(Long numTotalPhysicalBytes) { + this.numTotalPhysicalBytes = numTotalPhysicalBytes; + return this; + } + + @Override + Builder setNumActivePhysicalBytes(Long numActivePhysicalBytes) { + this.numActivePhysicalBytes = numActivePhysicalBytes; + return this; + } + + @Override + Builder setNumLongTermPhysicalBytes(Long numLongTermPhysicalBytes) { + this.numLongTermPhysicalBytes = numLongTermPhysicalBytes; + return this; + } + @Override Builder setNumRows(BigInteger numRows) { this.numRows = numRows; @@ -341,6 +425,13 @@ public TableInfo build() { this.lastModifiedTime = builder.lastModifiedTime; this.numBytes = builder.numBytes; this.numLongTermBytes = builder.numLongTermBytes; + this.numTimeTravelPhysicalBytes = builder.numTimeTravelPhysicalBytes; + this.numTotalLogicalBytes = builder.numTotalLogicalBytes; + this.numActiveLogicalBytes = builder.numActiveLogicalBytes; + this.numLongTermLogicalBytes = builder.numLongTermLogicalBytes; + this.numTotalPhysicalBytes = builder.numTotalPhysicalBytes; + this.numActivePhysicalBytes = builder.numActivePhysicalBytes; + this.numLongTermPhysicalBytes = builder.numLongTermPhysicalBytes; this.numRows = builder.numRows; this.definition = builder.definition; this.encryptionConfiguration = builder.encryptionConfiguration; @@ -426,6 +517,76 @@ public Long getNumLongTermBytes() { return numLongTermBytes; } + /** + * Returns the number of time travel physical bytes. + * + * @see Storage + * Pricing + */ + public Long getNumTimeTravelPhysicalBytes() { + return this.numTimeTravelPhysicalBytes; + } + + /** + * Returns the number of total logical bytes. + * + * @see Storage + * Pricing + */ + public Long getNumTotalLogicalBytes() { + return this.numTotalLogicalBytes; + } + + /** + * Returns the number of active logical bytes. + * + * @see Storage + * Pricing + */ + public Long getNumActiveLogicalBytes() { + return this.numActiveLogicalBytes; + } + + /** + * Returns the number of long term logical bytes. + * + * @see Storage + * Pricing + */ + public Long getNumLongTermLogicalBytes() { + return this.numLongTermLogicalBytes; + } + + /** + * Returns the number of total physical bytes. + * + * @see Storage + * Pricing + */ + public Long getNumTotalPhysicalBytes() { + return this.numTotalPhysicalBytes; + } + + /** + * Returns the number of active physical bytes. + * + * @see Storage + * Pricing + */ + public Long getNumActivePhysicalBytes() { + return this.numActivePhysicalBytes; + } + + /** + * Returns the number of long term physical bytes. + * + * @see Storage + * Pricing + */ + public Long getNumLongTermPhysicalBytes() { + return this.numLongTermPhysicalBytes; + } + /** Returns the number of rows of data in this table */ public BigInteger getNumRows() { return numRows; @@ -477,6 +638,13 @@ public String toString() { .add("lastModifiedTime", lastModifiedTime) .add("numBytes", numBytes) .add("numLongTermBytes", numLongTermBytes) + .add("numTimeTravelPhysicalBytes", numTimeTravelPhysicalBytes) + .add("numTotalLogicalBytes", numTotalLogicalBytes) + .add("numActiveLogicalBytes", numActiveLogicalBytes) + .add("numLongTermLogicalBytes", numLongTermLogicalBytes) + .add("numTotalPhysicalBytes", numTotalPhysicalBytes) + .add("numActivePhysicalBytes", numActivePhysicalBytes) + .add("numLongTermPhysicalBytes", numLongTermPhysicalBytes) .add("numRows", numRows) .add("definition", definition) .add("encryptionConfiguration", encryptionConfiguration) diff --git a/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/StandardTableDefinitionTest.java b/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/StandardTableDefinitionTest.java index 393b7fbc65..df0e5d79b0 100644 --- a/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/StandardTableDefinitionTest.java +++ b/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/StandardTableDefinitionTest.java @@ -51,6 +51,13 @@ public class StandardTableDefinitionTest { private static final Schema TABLE_SCHEMA = Schema.of(FIELD_SCHEMA1, FIELD_SCHEMA2, FIELD_SCHEMA3); private static final Long NUM_BYTES = 42L; private static final Long NUM_LONG_TERM_BYTES = 18L; + private static final Long NUM_TIME_TRAVEL_PHYSICAL_BYTES = 21L; + private static final Long NUM_TOTAL_LOGICAL_BYTES = 22L; + private static final Long NUM_ACTIVE_LOGICAL_BYTES = 23L; + private static final Long NUM_LONG_TERM_LOGICAL_BYTES = 24L; + private static final Long NUM_TOTAL_PHYSICAL_BYTES = 25L; + private static final Long NUM_ACTIVE_PHYSICAL_BYTES = 26L; + private static final Long NUM_LONG_TERM_PHYSICAL_BYTES = 27L; private static final Long NUM_ROWS = 43L; private static final String LOCATION = "US"; private static final StreamingBuffer STREAMING_BUFFER = new StreamingBuffer(1L, 2L, 3L); @@ -64,6 +71,13 @@ public class StandardTableDefinitionTest { .setNumBytes(NUM_BYTES) .setNumRows(NUM_ROWS) .setNumLongTermBytes(NUM_LONG_TERM_BYTES) + .setNumTimeTravelPhysicalBytes(NUM_TIME_TRAVEL_PHYSICAL_BYTES) + .setNumTotalLogicalBytes(NUM_TOTAL_LOGICAL_BYTES) + .setNumActiveLogicalBytes(NUM_ACTIVE_LOGICAL_BYTES) + .setNumLongTermLogicalBytes(NUM_LONG_TERM_LOGICAL_BYTES) + .setNumTotalPhysicalBytes(NUM_TOTAL_PHYSICAL_BYTES) + .setNumActivePhysicalBytes(NUM_ACTIVE_PHYSICAL_BYTES) + .setNumLongTermPhysicalBytes(NUM_LONG_TERM_PHYSICAL_BYTES) .setStreamingBuffer(STREAMING_BUFFER) .setSchema(TABLE_SCHEMA) .setTimePartitioning(TIME_PARTITIONING) @@ -93,6 +107,13 @@ public void testBuilder() { assertEquals(LOCATION, TABLE_DEFINITION.getLocation()); assertEquals(NUM_BYTES, TABLE_DEFINITION.getNumBytes()); assertEquals(NUM_LONG_TERM_BYTES, TABLE_DEFINITION.getNumLongTermBytes()); + assertEquals(NUM_TIME_TRAVEL_PHYSICAL_BYTES, TABLE_DEFINITION.getNumTimeTravelPhysicalBytes()); + assertEquals(NUM_TOTAL_LOGICAL_BYTES, TABLE_DEFINITION.getNumTotalLogicalBytes()); + assertEquals(NUM_ACTIVE_LOGICAL_BYTES, TABLE_DEFINITION.getNumActiveLogicalBytes()); + assertEquals(NUM_LONG_TERM_LOGICAL_BYTES, TABLE_DEFINITION.getNumLongTermLogicalBytes()); + assertEquals(NUM_TOTAL_PHYSICAL_BYTES, TABLE_DEFINITION.getNumTotalPhysicalBytes()); + assertEquals(NUM_ACTIVE_PHYSICAL_BYTES, TABLE_DEFINITION.getNumActivePhysicalBytes()); + assertEquals(NUM_LONG_TERM_PHYSICAL_BYTES, TABLE_DEFINITION.getNumLongTermPhysicalBytes()); assertEquals(NUM_ROWS, TABLE_DEFINITION.getNumRows()); assertEquals(STREAMING_BUFFER, TABLE_DEFINITION.getStreamingBuffer()); assertEquals(TIME_PARTITIONING, TABLE_DEFINITION.getTimePartitioning()); @@ -118,6 +139,13 @@ public void testOf() { assertNull(definition.getLocation()); assertNull(definition.getNumBytes()); assertNull(definition.getNumLongTermBytes()); + assertNull(definition.getNumTimeTravelPhysicalBytes()); + assertNull(definition.getNumTotalLogicalBytes()); + assertNull(definition.getNumActiveLogicalBytes()); + assertNull(definition.getNumLongTermLogicalBytes()); + assertNull(definition.getNumTotalPhysicalBytes()); + assertNull(definition.getNumActivePhysicalBytes()); + assertNull(definition.getNumLongTermPhysicalBytes()); assertNull(definition.getNumRows()); assertNull(definition.getStreamingBuffer()); assertNull(definition.getTimePartitioning()); @@ -176,6 +204,13 @@ private void compareStandardTableDefinition( assertEquals(expected.getType(), value.getType()); assertEquals(expected.getNumBytes(), value.getNumBytes()); assertEquals(expected.getNumLongTermBytes(), value.getNumLongTermBytes()); + assertEquals(expected.getNumTimeTravelPhysicalBytes(), value.getNumTimeTravelPhysicalBytes()); + assertEquals(expected.getNumTotalLogicalBytes(), value.getNumTotalLogicalBytes()); + assertEquals(expected.getNumActiveLogicalBytes(), value.getNumActiveLogicalBytes()); + assertEquals(expected.getNumLongTermLogicalBytes(), value.getNumLongTermLogicalBytes()); + assertEquals(expected.getNumTotalPhysicalBytes(), value.getNumTotalPhysicalBytes()); + assertEquals(expected.getNumActivePhysicalBytes(), value.getNumActivePhysicalBytes()); + assertEquals(expected.getNumLongTermPhysicalBytes(), value.getNumLongTermPhysicalBytes()); assertEquals(expected.getNumRows(), value.getNumRows()); assertEquals(expected.getLocation(), value.getLocation()); assertEquals(expected.getStreamingBuffer(), value.getStreamingBuffer()); diff --git a/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/TableInfoTest.java b/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/TableInfoTest.java index a44f700391..6283f71c21 100644 --- a/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/TableInfoTest.java +++ b/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/TableInfoTest.java @@ -58,6 +58,13 @@ public class TableInfoTest { private static final Schema TABLE_SCHEMA = Schema.of(FIELD_SCHEMA1, FIELD_SCHEMA2, FIELD_SCHEMA3); private static final Long NUM_BYTES = 42L; private static final Long NUM_LONG_TERM_BYTES = 21L; + private static final Long NUM_TIME_TRAVEL_PHYSICAL_BYTES = 21L; + private static final Long NUM_TOTAL_LOGICAL_BYTES = 22L; + private static final Long NUM_ACTIVE_LOGICAL_BYTES = 23L; + private static final Long NUM_LONG_TERM_LOGICAL_BYTES = 24L; + private static final Long NUM_TOTAL_PHYSICAL_BYTES = 25L; + private static final Long NUM_ACTIVE_PHYSICAL_BYTES = 26L; + private static final Long NUM_LONG_TERM_PHYSICAL_BYTES = 27L; private static final Long NUM_ROWS = 43L; private static final String LOCATION = "US"; private static final StandardTableDefinition.StreamingBuffer STREAMING_BUFFER = @@ -67,6 +74,13 @@ public class TableInfoTest { .setLocation(LOCATION) .setNumBytes(NUM_BYTES) .setNumLongTermBytes(NUM_LONG_TERM_BYTES) + .setNumTimeTravelPhysicalBytes(NUM_TIME_TRAVEL_PHYSICAL_BYTES) + .setNumTotalLogicalBytes(NUM_TOTAL_LOGICAL_BYTES) + .setNumActiveLogicalBytes(NUM_ACTIVE_LOGICAL_BYTES) + .setNumLongTermLogicalBytes(NUM_LONG_TERM_LOGICAL_BYTES) + .setNumTotalPhysicalBytes(NUM_TOTAL_PHYSICAL_BYTES) + .setNumActivePhysicalBytes(NUM_ACTIVE_PHYSICAL_BYTES) + .setNumLongTermPhysicalBytes(NUM_LONG_TERM_PHYSICAL_BYTES) .setNumRows(NUM_ROWS) .setStreamingBuffer(STREAMING_BUFFER) .setSchema(TABLE_SCHEMA) @@ -102,6 +116,13 @@ public class TableInfoTest { .setLastModifiedTime(LAST_MODIFIED_TIME) .setNumBytes(NUM_BYTES) .setNumLongTermBytes(NUM_LONG_TERM_BYTES) + .setNumTimeTravelPhysicalBytes(NUM_TIME_TRAVEL_PHYSICAL_BYTES) + .setNumTotalLogicalBytes(NUM_TOTAL_LOGICAL_BYTES) + .setNumActiveLogicalBytes(NUM_ACTIVE_LOGICAL_BYTES) + .setNumLongTermLogicalBytes(NUM_LONG_TERM_LOGICAL_BYTES) + .setNumTotalPhysicalBytes(NUM_TOTAL_PHYSICAL_BYTES) + .setNumActivePhysicalBytes(NUM_ACTIVE_PHYSICAL_BYTES) + .setNumLongTermPhysicalBytes(NUM_LONG_TERM_PHYSICAL_BYTES) .setNumRows(BigInteger.valueOf(NUM_ROWS)) .setSelfLink(SELF_LINK) .setLabels(Collections.singletonMap("a", "b")) @@ -166,6 +187,13 @@ public void testBuilder() { assertEquals(SELF_LINK, TABLE_INFO.getSelfLink()); assertEquals(NUM_BYTES, TABLE_INFO.getNumBytes()); assertEquals(NUM_LONG_TERM_BYTES, TABLE_INFO.getNumLongTermBytes()); + assertEquals(NUM_TIME_TRAVEL_PHYSICAL_BYTES, TABLE_INFO.getNumTimeTravelPhysicalBytes()); + assertEquals(NUM_TOTAL_LOGICAL_BYTES, TABLE_INFO.getNumTotalLogicalBytes()); + assertEquals(NUM_ACTIVE_LOGICAL_BYTES, TABLE_INFO.getNumActiveLogicalBytes()); + assertEquals(NUM_LONG_TERM_LOGICAL_BYTES, TABLE_INFO.getNumLongTermLogicalBytes()); + assertEquals(NUM_TOTAL_PHYSICAL_BYTES, TABLE_INFO.getNumTotalPhysicalBytes()); + assertEquals(NUM_ACTIVE_PHYSICAL_BYTES, TABLE_INFO.getNumActivePhysicalBytes()); + assertEquals(NUM_LONG_TERM_PHYSICAL_BYTES, TABLE_INFO.getNumLongTermPhysicalBytes()); assertEquals(BigInteger.valueOf(NUM_ROWS), TABLE_INFO.getNumRows()); assertEquals(REQUIRE_PARTITION_FILTER, TABLE_INFO.getRequirePartitionFilter()); @@ -271,6 +299,13 @@ private void compareTableInfo(TableInfo expected, TableInfo value) { assertEquals(expected.getLastModifiedTime(), value.getLastModifiedTime()); assertEquals(expected.getNumBytes(), value.getNumBytes()); assertEquals(expected.getNumLongTermBytes(), value.getNumLongTermBytes()); + assertEquals(expected.getNumTimeTravelPhysicalBytes(), value.getNumTimeTravelPhysicalBytes()); + assertEquals(expected.getNumTotalLogicalBytes(), value.getNumTotalLogicalBytes()); + assertEquals(expected.getNumActiveLogicalBytes(), value.getNumActiveLogicalBytes()); + assertEquals(expected.getNumLongTermLogicalBytes(), value.getNumLongTermLogicalBytes()); + assertEquals(expected.getNumTotalPhysicalBytes(), value.getNumTotalPhysicalBytes()); + assertEquals(expected.getNumActivePhysicalBytes(), value.getNumActivePhysicalBytes()); + assertEquals(expected.getNumLongTermPhysicalBytes(), value.getNumLongTermPhysicalBytes()); assertEquals(expected.getNumRows(), value.getNumRows()); assertEquals(expected.getSelfLink(), value.getSelfLink()); assertEquals(expected.getLabels(), value.getLabels()); diff --git a/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/it/ITBigQueryTest.java b/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/it/ITBigQueryTest.java index bf59c2b67e..429ddf58d2 100644 --- a/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/it/ITBigQueryTest.java +++ b/google-cloud-bigquery/src/test/java/com/google/cloud/bigquery/it/ITBigQueryTest.java @@ -1451,6 +1451,9 @@ public void testCreateAndGetTable() { assertNotNull(remoteTable.getLastModifiedTime()); assertNotNull(remoteTable.getDefinition().getNumBytes()); assertNotNull(remoteTable.getDefinition().getNumLongTermBytes()); + assertNotNull(remoteTable.getDefinition().getNumTotalLogicalBytes()); + assertNotNull(remoteTable.getDefinition().getNumActiveLogicalBytes()); + assertNotNull(remoteTable.getDefinition().getNumLongTermLogicalBytes()); assertNotNull(remoteTable.getDefinition().getNumRows()); assertEquals( partitioning, remoteTable.getDefinition().getTimePartitioning()); @@ -1484,6 +1487,13 @@ public void testCreateAndGetTableWithSelectedField() { assertNull(remoteTable.getLastModifiedTime()); assertNull(remoteTable.getDefinition().getNumBytes()); assertNull(remoteTable.getDefinition().getNumLongTermBytes()); + assertNull(remoteTable.getDefinition().getNumTimeTravelPhysicalBytes()); + assertNull(remoteTable.getDefinition().getNumTotalLogicalBytes()); + assertNull(remoteTable.getDefinition().getNumActiveLogicalBytes()); + assertNull(remoteTable.getDefinition().getNumLongTermLogicalBytes()); + assertNull(remoteTable.getDefinition().getNumTotalPhysicalBytes()); + assertNull(remoteTable.getDefinition().getNumActivePhysicalBytes()); + assertNull(remoteTable.getDefinition().getNumLongTermPhysicalBytes()); assertNull(remoteTable.getDefinition().getNumRows()); assertNull(remoteTable.getDefinition().getTimePartitioning()); assertNull(remoteTable.getDefinition().getClustering()); @@ -1872,6 +1882,13 @@ public void testUpdateTableWithSelectedFields() { assertNull(updatedTable.getLastModifiedTime()); assertNull(updatedTable.getDefinition().getNumBytes()); assertNull(updatedTable.getDefinition().getNumLongTermBytes()); + assertNull(updatedTable.getDefinition().getNumTimeTravelPhysicalBytes()); + assertNull(updatedTable.getDefinition().getNumTotalLogicalBytes()); + assertNull(updatedTable.getDefinition().getNumActiveLogicalBytes()); + assertNull(updatedTable.getDefinition().getNumLongTermLogicalBytes()); + assertNull(updatedTable.getDefinition().getNumTotalPhysicalBytes()); + assertNull(updatedTable.getDefinition().getNumActivePhysicalBytes()); + assertNull(updatedTable.getDefinition().getNumLongTermPhysicalBytes()); assertNull(updatedTable.getDefinition().getNumRows()); assertTrue(createdTable.delete()); }