This is an automated email from the ASF dual-hosted git repository.

lidavidm pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-adbc.git


The following commit(s) were added to refs/heads/main by this push:
     new 53bfd1ab refactor(c/driver/postgresql): No naked new in copy/reader.h 
(#1503)
53bfd1ab is described below

commit 53bfd1abe82ae0d0446537d3da16c3c4641bc340
Author: William Ayd <[email protected]>
AuthorDate: Thu Feb 1 08:23:25 2024 -0500

    refactor(c/driver/postgresql): No naked new in copy/reader.h (#1503)
---
 c/driver/postgresql/copy/reader.h | 59 +++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 31 deletions(-)

diff --git a/c/driver/postgresql/copy/reader.h 
b/c/driver/postgresql/copy/reader.h
index a64219cf..c3c9acb3 100644
--- a/c/driver/postgresql/copy/reader.h
+++ b/c/driver/postgresql/copy/reader.h
@@ -702,10 +702,9 @@ static inline ArrowErrorCode ErrorCantConvert(ArrowError* 
error,
   return EINVAL;
 }
 
-static inline ArrowErrorCode MakeCopyFieldReader(const PostgresType& pg_type,
-                                                 ArrowSchema* schema,
-                                                 PostgresCopyFieldReader** out,
-                                                 ArrowError* error) {
+static inline ArrowErrorCode MakeCopyFieldReader(
+    const PostgresType& pg_type, ArrowSchema* schema,
+    std::unique_ptr<PostgresCopyFieldReader>* out, ArrowError* error) {
   ArrowSchemaView schema_view;
   NANOARROW_RETURN_NOT_OK(ArrowSchemaViewInit(&schema_view, schema, nullptr));
 
@@ -713,7 +712,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_BOOL:
       switch (pg_type.type_id()) {
         case PostgresTypeId::kBool:
-          *out = new PostgresCopyBooleanFieldReader();
+          *out = std::make_unique<PostgresCopyBooleanFieldReader>();
           return NANOARROW_OK;
         default:
           return ErrorCantConvert(error, pg_type, schema_view);
@@ -722,7 +721,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_INT16:
       switch (pg_type.type_id()) {
         case PostgresTypeId::kInt2:
-          *out = new PostgresCopyNetworkEndianFieldReader<int16_t>();
+          *out = 
std::make_unique<PostgresCopyNetworkEndianFieldReader<int16_t>>();
           return NANOARROW_OK;
         default:
           return ErrorCantConvert(error, pg_type, schema_view);
@@ -733,7 +732,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
         case PostgresTypeId::kInt4:
         case PostgresTypeId::kOid:
         case PostgresTypeId::kRegproc:
-          *out = new PostgresCopyNetworkEndianFieldReader<int32_t>();
+          *out = 
std::make_unique<PostgresCopyNetworkEndianFieldReader<int32_t>>();
           return NANOARROW_OK;
         default:
           return ErrorCantConvert(error, pg_type, schema_view);
@@ -742,7 +741,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_INT64:
       switch (pg_type.type_id()) {
         case PostgresTypeId::kInt8:
-          *out = new PostgresCopyNetworkEndianFieldReader<int64_t>();
+          *out = 
std::make_unique<PostgresCopyNetworkEndianFieldReader<int64_t>>();
           return NANOARROW_OK;
         default:
           return ErrorCantConvert(error, pg_type, schema_view);
@@ -751,7 +750,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_FLOAT:
       switch (pg_type.type_id()) {
         case PostgresTypeId::kFloat4:
-          *out = new PostgresCopyNetworkEndianFieldReader<uint32_t>();
+          *out = 
std::make_unique<PostgresCopyNetworkEndianFieldReader<uint32_t>>();
           return NANOARROW_OK;
         default:
           return ErrorCantConvert(error, pg_type, schema_view);
@@ -760,7 +759,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_DOUBLE:
       switch (pg_type.type_id()) {
         case PostgresTypeId::kFloat8:
-          *out = new PostgresCopyNetworkEndianFieldReader<uint64_t>();
+          *out = 
std::make_unique<PostgresCopyNetworkEndianFieldReader<uint64_t>>();
           return NANOARROW_OK;
         default:
           return ErrorCantConvert(error, pg_type, schema_view);
@@ -774,10 +773,10 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
         case PostgresTypeId::kBpchar:
         case PostgresTypeId::kName:
         case PostgresTypeId::kEnum:
-          *out = new PostgresCopyBinaryFieldReader();
+          *out = std::make_unique<PostgresCopyBinaryFieldReader>();
           return NANOARROW_OK;
         case PostgresTypeId::kNumeric:
-          *out = new PostgresCopyNumericFieldReader();
+          *out = std::make_unique<PostgresCopyNumericFieldReader>();
           return NANOARROW_OK;
         default:
           return ErrorCantConvert(error, pg_type, schema_view);
@@ -786,7 +785,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_BINARY:
       // No need to check pg_type here: we can return the bytes of any
       // Postgres type as binary.
-      *out = new PostgresCopyBinaryFieldReader();
+      *out = std::make_unique<PostgresCopyBinaryFieldReader>();
       return NANOARROW_OK;
 
     case NANOARROW_TYPE_LIST:
@@ -799,16 +798,15 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
             return EINVAL;
           }
 
-          auto array_reader = std::unique_ptr<PostgresCopyArrayFieldReader>(
-              new PostgresCopyArrayFieldReader());
+          auto array_reader = std::make_unique<PostgresCopyArrayFieldReader>();
           array_reader->Init(pg_type);
 
-          PostgresCopyFieldReader* child_reader;
+          std::unique_ptr<PostgresCopyFieldReader> child_reader;
           NANOARROW_RETURN_NOT_OK(MakeCopyFieldReader(
               pg_type.child(0), schema->children[0], &child_reader, error));
-          
array_reader->InitChild(std::unique_ptr<PostgresCopyFieldReader>(child_reader));
+          array_reader->InitChild(std::move(child_reader));
 
-          *out = array_reader.release();
+          *out = std::move(array_reader);
           return NANOARROW_OK;
         }
         default:
@@ -827,19 +825,17 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
             return EINVAL;
           }
 
-          auto record_reader = std::unique_ptr<PostgresCopyRecordFieldReader>(
-              new PostgresCopyRecordFieldReader());
+          auto record_reader = 
std::make_unique<PostgresCopyRecordFieldReader>();
           record_reader->Init(pg_type);
 
           for (int64_t i = 0; i < pg_type.n_children(); i++) {
-            PostgresCopyFieldReader* child_reader;
+            std::unique_ptr<PostgresCopyFieldReader> child_reader;
             NANOARROW_RETURN_NOT_OK(MakeCopyFieldReader(
                 pg_type.child(i), schema->children[i], &child_reader, error));
-            record_reader->AppendChild(
-                std::unique_ptr<PostgresCopyFieldReader>(child_reader));
+            record_reader->AppendChild(std::move(child_reader));
           }
 
-          *out = record_reader.release();
+          *out = std::move(record_reader);
           return NANOARROW_OK;
         }
         default:
@@ -849,12 +845,13 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_DATE32: {
       // 2000-01-01
       constexpr int32_t kPostgresDateEpoch = 10957;
-      *out = new PostgresCopyNetworkEndianFieldReader<int32_t, 
kPostgresDateEpoch>();
+      *out = std::make_unique<
+          PostgresCopyNetworkEndianFieldReader<int32_t, kPostgresDateEpoch>>();
       return NANOARROW_OK;
     }
 
     case NANOARROW_TYPE_TIME64: {
-      *out = new PostgresCopyNetworkEndianFieldReader<int64_t>();
+      *out = std::make_unique<PostgresCopyNetworkEndianFieldReader<int64_t>>();
       return NANOARROW_OK;
     }
 
@@ -864,8 +861,8 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
         case PostgresTypeId::kTimestamptz: {
           // 2000-01-01 00:00:00.000000 in microseconds
           constexpr int64_t kPostgresTimestampEpoch = 946684800000000;
-          *out = new PostgresCopyNetworkEndianFieldReader<int64_t,
-                                                          
kPostgresTimestampEpoch>();
+          *out = std::make_unique<
+              PostgresCopyNetworkEndianFieldReader<int64_t, 
kPostgresTimestampEpoch>>();
           return NANOARROW_OK;
         }
         default:
@@ -874,7 +871,7 @@ static inline ArrowErrorCode MakeCopyFieldReader(const 
PostgresType& pg_type,
     case NANOARROW_TYPE_INTERVAL_MONTH_DAY_NANO:
       switch (pg_type.type_id()) {
         case PostgresTypeId::kInterval: {
-          *out = new PostgresCopyIntervalFieldReader();
+          *out = std::make_unique<PostgresCopyIntervalFieldReader>();
           return NANOARROW_OK;
         }
         default:
@@ -940,10 +937,10 @@ class PostgresCopyStreamReader {
 
     for (int64_t i = 0; i < root_type.n_children(); i++) {
       const PostgresType& child_type = root_type.child(i);
-      PostgresCopyFieldReader* child_reader;
+      std::unique_ptr<PostgresCopyFieldReader> child_reader;
       NANOARROW_RETURN_NOT_OK(
           MakeCopyFieldReader(child_type, schema_->children[i], &child_reader, 
error));
-      
root_reader_.AppendChild(std::unique_ptr<PostgresCopyFieldReader>(child_reader));
+      root_reader_.AppendChild(std::move(child_reader));
     }
 
     NANOARROW_RETURN_NOT_OK(root_reader_.InitSchema(schema_.get()));

Reply via email to