feat: add PG.OID type

google/cloud/spanner/integration_tests/data_types_integration_test.cc

@@ -292,6 +292,18 @@ TEST_F(PgDataTypeIntegrationTest, WriteReadNumeric) {
   EXPECT_THAT(result, IsOkAndHolds(UnorderedElementsAreArray(data)));
 }
 
+TEST_F(PgDataTypeIntegrationTest, WriteReadPgOid) {
+  if (UsingEmulator()) GTEST_SKIP() << "emulator does not support PG.OID";
+
+  std::vector<PgNumeric> const data = {
+      PgOid("0"),   //
+      PgOid("42"),  //
+      PgOid("999"), //
+  };
+  auto result = WriteReadData(*client_, data, "PgOidValue");
+  EXPECT_THAT(result, IsOkAndHolds(UnorderedElementsAreArray(data)));
+}
+
 TEST_F(DataTypeIntegrationTest, WriteReadArrayBool) {
   std::vector<std::vector<bool>> const data = {
       std::vector<bool>{},

google/cloud/spanner/internal/connection_impl_test.cc

@@ -1069,6 +1069,49 @@ TEST(ConnectionImplTest, ExecuteQueryNumericParameter) {
   }
 }
 
+TEST(ConnectionImplTest, ExecuteQueryPgOidResult) {
+  auto mock = std::make_shared<spanner_testing::MockSpannerStub>();
+  auto db = spanner::Database("placeholder_project", "placeholder_instance",
+                              "placeholder_database_id");
+  EXPECT_CALL(*mock, BatchCreateSessions(_, HasDatabase(db)))
+      .WillOnce(Return(MakeSessionsResponse({"test-session-name"})));
+  auto constexpr kText = R"pb(
+    metadata: {
+      row_type: {
+        fields: {
+          name: "ColumnA",
+          type: { code: INT64 type_annotation: PG_OID }
+        }
+        fields: {
+          name: "ColumnB",
+          type: { code: INT64 type_annotation: PG_OID }
+        }
+      }
+    }
+    values: { string_value: "42" }
+    values: { null_value: NULL_VALUE }
+    values: { string_value: "0" }
+    values: { string_value: "999" }
+  )pb";
+  EXPECT_CALL(*mock, ExecuteStreamingSql)
+      .WillOnce(Return(ByMove(MakeReader<PartialResultSet>({kText}))));
+
+  auto conn = MakeConnectionImpl(db, mock);
+  internal::OptionsSpan span(MakeLimitedTimeOptions());
+  auto rows = conn->ExecuteQuery(
+      {MakeSingleUseTransaction(spanner::Transaction::ReadOnlyOptions()),
+       spanner::SqlStatement("SELECT * FROM Table")});
+
+  using RowType = std::tuple<spanner::PgOid, absl::optional<spanner::PgOid>>;
+  auto stream = spanner::StreamOf<RowType>(rows);
+  auto actual = std::vector<StatusOr<RowType>>{stream.begin(), stream.end()};
+  EXPECT_THAT(
+      actual,
+      ElementsAre(
+          IsOkAndHolds(RowType(spanner::PgOid("42"), absl::nullopt)),
+          IsOkAndHolds(RowType(spanner::PgOid("0"), spanner::PgOid("999")))));
+}
+
 /// @test Verify implicit "begin transaction" in ExecuteQuery() works.
 TEST(ConnectionImplTest, ExecuteQueryImplicitBeginTransaction) {
   auto mock = std::make_shared<spanner_testing::MockSpannerStub>();

google/cloud/spanner/oid.h

@@ -0,0 +1,73 @@
+// Copyright 2023 Google LLC
+//
+// 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
+//
+//     https://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.
+
+#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_OID_H
+#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_OID_H
+
+
+#include "google/cloud/spanner/version.h"
+#include <ostream>
+#include <string>
+
+namespace google {
+namespace cloud {
+namespace spanner {
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
+
+class PgOid {
+ public:
+  /// @name Regular value type, supporting copy, assign, move.
+  ///@{
+  PgOid(PgOid const&) = default;
+  PgOid& operator=(PgOid const&) = default;
+  PgOid(PgOid&&) = default;
+  PgOid& operator=(PgOid&&) = default;
+  ///@}
+
+  /**
+   * Construction from an oid string. Note that there is no check here that the
+   * argument string is indeed well-formatted. Error detection will be delayed
+   * until the value is passed to Spanner.
+   */
+  explicit PgOid(std::string value) : rep_(value) {}
+
+  /// @name Conversion to a JSON-formatted string.
+  ///@{
+  explicit operator std::string() const& { return rep_; }
+  explicit operator std::string() && { return std::move(rep_); }
+  ///@}
+
+ private:
+  std::string rep_;
+};
+
+/// @name Relational operators
+///@{
+inline bool operator==(PgOid const& lhs, PgOid const& rhs) {
+  return std::string(lhs) == std::string(rhs);
+}
+inline bool operator!=(PgOid const& lhs, PgOid const& rhs) { return !(lhs == rhs); }
+///@}
+
+/// Outputs an Oid formatted string to the provided stream.
+inline std::ostream& operator<<(std::ostream& os, PgOid const& oid) {
+  return os << std::string(oid);
+}
+
+GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
+}  // namespace spanner
+}  // namespace cloud
+}  // namespace google
+
+#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_OID_H

google/cloud/spanner/value.cc

@@ -259,6 +259,12 @@ bool Value::TypeProtoIs(PgNumeric const&,
              google::spanner::v1::TypeAnnotationCode::PG_NUMERIC;
 }
 
+bool Value::TypeProtoIs(PgOid const&, google::spanner::v1::Type const& type) {
+  return type.code() == google::spanner::v1::TypeCode::INT64 &&
+         type.type_annotation() ==
+             google::spanner::v1::TypeAnnotationCode::PG_OID;
+}
+
 //
 // Value::MakeTypeProto
 //
@@ -323,6 +329,13 @@ google::spanner::v1::Type Value::MakeTypeProto(PgNumeric const&) {
   return t;
 }
 
+google::spanner::v1::Type Value::MakeTypeProto(PgOid const&) {
+  google::spanner::v1::Type t;
+  t.set_code(google::spanner::v1::TypeCode::INT64);
+  t.set_type_annotation(google::spanner::v1::TypeAnnotationCode::PG_OID);
+  return t;
+}
+
 google::spanner::v1::Type Value::MakeTypeProto(Timestamp) {
   google::spanner::v1::Type t;
   t.set_code(google::spanner::v1::TypeCode::TIMESTAMP);
@@ -413,6 +426,12 @@ google::protobuf::Value Value::MakeValueProto(PgNumeric n) {
   return v;
 }
 
+google::protobuf::Value Value::MakeValueProto(PgOid n) {
+  google::protobuf::Value v;
+  v.set_string_value(std::string(std::move(n)));
+  return v;
+}
+
 google::protobuf::Value Value::MakeValueProto(Timestamp ts) {
   google::protobuf::Value v;
   v.set_string_value(spanner_internal::TimestampToRFC3339(ts));
@@ -562,6 +581,14 @@ StatusOr<PgNumeric> Value::GetValue(PgNumeric const&,
   return *decoded;
 }
 
+StatusOr<PgOid> Value::GetValue(PgOid const&, google::protobuf::Value const& pv,
+                                google::spanner::v1::Type const&) {
+  if (pv.kind_case() != google::protobuf::Value::kStringValue) {
+    return Status(StatusCode::kUnknown, "missing OID");
+  }
+  return PgOid(pv.string_value());
+}
+
 StatusOr<Timestamp> Value::GetValue(Timestamp,
                                     google::protobuf::Value const& pv,
                                     google::spanner::v1::Type const&) {

google/cloud/spanner/value.h

@@ -20,6 +20,7 @@
 #include "google/cloud/spanner/internal/tuple_utils.h"
 #include "google/cloud/spanner/json.h"
 #include "google/cloud/spanner/numeric.h"
+#include "google/cloud/spanner/oid.h"
 #include "google/cloud/spanner/timestamp.h"
 #include "google/cloud/spanner/version.h"
 #include "google/cloud/internal/throw_delegate.h"
@@ -68,6 +69,7 @@ GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
  * JSONB        | `google::cloud::spanner::JsonB`
  * NUMERIC      | `google::cloud::spanner::Numeric`
  * NUMERIC(PG)  | `google::cloud::spanner::PgNumeric`
+ * OID(PG)      | `google::cloud::spanner::PgOid`
  * TIMESTAMP    | `google::cloud::spanner::Timestamp`
  * DATE         | `absl::CivilDay`
  * ARRAY        | `std::vector<T>`  // [1]
@@ -201,6 +203,8 @@ class Value {
   /// @copydoc Value(bool)
   explicit Value(PgNumeric v) : Value(PrivateConstructor{}, std::move(v)) {}
   /// @copydoc Value(bool)
+  explicit Value(PgOid v) : Value(PrivateConstructor{}, std::move(v)) {}
+  /// @copydoc Value(bool)
   explicit Value(Timestamp v) : Value(PrivateConstructor{}, std::move(v)) {}
   /// @copydoc Value(bool)
   explicit Value(CommitTimestamp v)
@@ -372,6 +376,7 @@ class Value {
   static bool TypeProtoIs(JsonB const&, google::spanner::v1::Type const&);
   static bool TypeProtoIs(Numeric const&, google::spanner::v1::Type const&);
   static bool TypeProtoIs(PgNumeric const&, google::spanner::v1::Type const&);
+  static bool TypeProtoIs(PgOid const&, google::spanner::v1::Type const&);
   template <typename T>
   static bool TypeProtoIs(absl::optional<T>,
                           google::spanner::v1::Type const& type) {
@@ -421,6 +426,7 @@ class Value {
   static google::spanner::v1::Type MakeTypeProto(JsonB const&);
   static google::spanner::v1::Type MakeTypeProto(Numeric const&);
   static google::spanner::v1::Type MakeTypeProto(PgNumeric const&);
+  static google::spanner::v1::Type MakeTypeProto(PgOid const&);
   static google::spanner::v1::Type MakeTypeProto(Timestamp);
   static google::spanner::v1::Type MakeTypeProto(CommitTimestamp);
   static google::spanner::v1::Type MakeTypeProto(absl::CivilDay);
@@ -484,6 +490,7 @@ class Value {
   static google::protobuf::Value MakeValueProto(JsonB j);
   static google::protobuf::Value MakeValueProto(Numeric n);
   static google::protobuf::Value MakeValueProto(PgNumeric n);
+  static google::protobuf::Value MakeValueProto(PgOid n);
   static google::protobuf::Value MakeValueProto(Timestamp ts);
   static google::protobuf::Value MakeValueProto(CommitTimestamp ts);
   static google::protobuf::Value MakeValueProto(absl::CivilDay d);
@@ -555,6 +562,8 @@ class Value {
   static StatusOr<PgNumeric> GetValue(PgNumeric const&,
                                       google::protobuf::Value const&,
                                       google::spanner::v1::Type const&);
+  static StatusOr<PgOid> GetValue(PgOid const&, google::protobuf::Value const&,
+                                  google::spanner::v1::Type const&);
   static StatusOr<Timestamp> GetValue(Timestamp, google::protobuf::Value const&,
                                       google::spanner::v1::Type const&);
   static StatusOr<CommitTimestamp> GetValue(CommitTimestamp,

google/cloud/spanner/value_test.cc

@@ -247,6 +247,7 @@ TEST(Value, Equality) {
       {Value(JsonB("42")), Value(JsonB("true"))},
       {Value(MakeNumeric(0).value()), Value(MakeNumeric(1).value())},
       {Value(MakePgNumeric(0).value()), Value(MakePgNumeric(1).value())},
+      {Value(PgOid("200")), Value(PgOid("999"))},
       {Value(absl::CivilDay(1970, 1, 1)), Value(absl::CivilDay(2020, 3, 15))},
       {Value(std::vector<double>{1.2, 3.4}),
        Value(std::vector<double>{4.5, 6.7})},
@@ -753,6 +754,21 @@ TEST(Value, ProtoConversionNumeric) {
   }
 }
 
+TEST(Value, ProtoConversionPgOid) {
+  for (auto const& x : std::vector<PgOid>{
+           PgOid("0"),
+           PgOid("200"),
+           PgOid("999"),
+       }) {
+    Value const v(x);
+    auto const p = spanner_internal::ToProto(v);
+    EXPECT_EQ(v, spanner_internal::FromProto(p.first, p.second));
+    EXPECT_EQ(p.first.code(), google::spanner::v1::TypeCode::INT64);
+    EXPECT_EQ(p.first.type_annotation(), google::spanner::v1::TypeAnnotationCode::PG_OID);
+    EXPECT_EQ(std::string(x), p.second.string_value());
+  }
+}
+
 TEST(Value, ProtoConversionTimestamp) {
   for (auto ts : TestTimes()) {
     Value const v(ts);
@@ -975,6 +991,21 @@ TEST(Value, GetBadNumeric) {
   EXPECT_THAT(v.get<std::int64_t>(), Not(IsOk()));
 }
 
+TEST(Value, GetBadPgOid) {
+  Value v(PgOid("1"));
+  ClearProtoKind(v);
+  EXPECT_THAT(v.get<std::string>(), Not(IsOk()));
+
+  SetProtoKind(v, google::protobuf::NULL_VALUE);
+  EXPECT_THAT(v.get<PgOid>(), Not(IsOk()));
+
+  SetProtoKind(v, true);
+  EXPECT_THAT(v.get<PgOid>(), Not(IsOk()));
+
+  SetProtoKind(v, 0.0);
+  EXPECT_THAT(v.get<PgOid>(), Not(IsOk()));
+}
+
 TEST(Value, GetBadInt) {
   Value v(42);
   ClearProtoKind(v);
@@ -1164,6 +1195,7 @@ TEST(Value, OutputStream) {
       {Value(JsonB("true")), "true", normal},
       {Value(MakeNumeric(1234567890).value()), "1234567890", normal},
       {Value(MakePgNumeric(1234567890).value()), "1234567890", normal},
+      {Value(PgOid("1234567890")), "1234567890", normal},
       {Value(absl::CivilDay()), "1970-01-01", normal},
       {Value(Timestamp()), "1970-01-01T00:00:00Z", normal},
 
@@ -1189,6 +1221,7 @@ TEST(Value, OutputStream) {
       {MakeNullValue<Json>(), "NULL", normal},
       {MakeNullValue<JsonB>(), "NULL", normal},
       {MakeNullValue<Numeric>(), "NULL", normal},
+      {MakeNullValue<PgOid>(), "NULL", normal},
       {MakeNullValue<absl::CivilDay>(), "NULL", normal},
       {MakeNullValue<Timestamp>(), "NULL", normal},
 
@@ -1343,6 +1376,11 @@ TEST(Value, OutputStreamMatchesT) {
   StreamMatchesValueStream(MakePgNumeric(42).value());
   StreamMatchesValueStream(MakePgNumeric("NaN").value());
 
+  // PgOid
+  StreamMatchesValueStream(PgOid("999"));
+  StreamMatchesValueStream(PgOid("-1"));
+  StreamMatchesValueStream(PgOid("0"));
+
   // Date
   StreamMatchesValueStream(absl::CivilDay(1, 1, 1));
   StreamMatchesValueStream(absl::CivilDay());