Fix member variable naming

cpp/src/arrow/flight/sql/odbc/flight_sql/config/configuration.cc

@@ -148,15 +148,15 @@ void Configuration::LoadDsn(const std::string& dsn) {
   }
 }
 
-void Configuration::Clear() { this->properties.clear(); }
+void Configuration::Clear() { this->properties_.clear(); }
 
 bool Configuration::IsSet(const std::string_view& key) const {
-  return 0 != this->properties.count(std::string(key));
+  return 0 != this->properties_.count(std::string(key));
 }
 
 const std::string& Configuration::Get(const std::string_view& key) const {
-  const auto itr = this->properties.find(std::string(key));
-  if (itr == this->properties.cend()) {
+  const auto itr = this->properties_.find(std::string(key));
+  if (itr == this->properties_.cend()) {
     static const std::string empty("");
     return empty;
   }
@@ -171,25 +171,25 @@ void Configuration::Set(const std::string_view& key, const std::wstring& wValue)
 void Configuration::Set(const std::string_view& key, const std::string& value) {
   const std::string copy = boost::trim_copy(value);
   if (!copy.empty()) {
-    this->properties[std::string(key)] = value;
+    this->properties_[std::string(key)] = value;
   }
 }
 
 void Configuration::Emplace(const std::string_view& key, std::string&& value) {
   const std::string copy = boost::trim_copy(value);
   if (!copy.empty()) {
-    this->properties.emplace(
+    this->properties_.emplace(
         std::make_pair(std::move(std::string(key)), std::move(value)));
   }
 }
 
 const driver::odbcabstraction::Connection::ConnPropertyMap& Configuration::GetProperties()
     const {
-  return this->properties;
+  return this->properties_;
 }
 
 std::vector<std::string> Configuration::GetCustomKeys() const {
-  driver::odbcabstraction::Connection::ConnPropertyMap copy_props(properties);
+  driver::odbcabstraction::Connection::ConnPropertyMap copy_props(properties_);
   for (auto& key : FlightSqlConnection::ALL_KEYS) {
     copy_props.erase(std::string(key));
   }

cpp/src/arrow/flight/sql/odbc/flight_sql/config/connection_string_parser.cc

@@ -31,7 +31,7 @@ namespace driver {
 namespace flight_sql {
 namespace config {
 
-ConnectionStringParser::ConnectionStringParser(Configuration& cfg) : cfg(cfg) {
+ConnectionStringParser::ConnectionStringParser(Configuration& cfg) : cfg_(cfg) {
   // No-op.
 }
 
@@ -73,7 +73,7 @@ void ConnectionStringParser::ParseConnectionString(const char* str, size_t len,
         value = value.substr(1, value.size() - 2);
       }
 
-      cfg.Set(key, value);
+      cfg_.Set(key, value);
     }
 
     if (!attr_begin) break;

cpp/src/arrow/flight/sql/odbc/flight_sql/flight_sql_connection.cc

@@ -204,9 +204,9 @@ void FlightSqlConnection::Connect(const ConnPropertyMap& properties,
 
 void FlightSqlConnection::PopulateMetadataSettings(
     const Connection::ConnPropertyMap& conn_property_map) {
-  metadata_settings_.string_column_length_ = GetStringColumnLength(conn_property_map);
-  metadata_settings_.use_wide_char_ = GetUseWideChar(conn_property_map);
-  metadata_settings_.chunk_buffer_capacity_ = GetChunkBufferCapacity(conn_property_map);
+  metadata_settings_.string_column_length = GetStringColumnLength(conn_property_map);
+  metadata_settings_.use_wide_char = GetUseWideChar(conn_property_map);
+  metadata_settings_.chunk_buffer_capacity = GetChunkBufferCapacity(conn_property_map);
 }
 
 boost::optional<int32_t> FlightSqlConnection::GetStringColumnLength(

cpp/src/arrow/flight/sql/odbc/flight_sql/flight_sql_result_set.cc

@@ -52,7 +52,7 @@ FlightSqlResultSet::FlightSqlResultSet(
     const odbcabstraction::MetadataSettings& metadata_settings)
     : metadata_settings_(metadata_settings),
       chunk_buffer_(flight_sql_client, client_options, call_options, flight_info,
-                    metadata_settings_.chunk_buffer_capacity_),
+                    metadata_settings_.chunk_buffer_capacity),
       transformer_(transformer),
       metadata_(transformer
                     ? new FlightSqlResultSetMetadata(transformer->GetTransformedSchema(),
@@ -72,7 +72,7 @@ FlightSqlResultSet::FlightSqlResultSet(
   }
 
   for (size_t i = 0; i < columns_.size(); ++i) {
-    columns_[i] = FlightSqlResultSetColumn(metadata_settings.use_wide_char_);
+    columns_[i] = FlightSqlResultSetColumn(metadata_settings.use_wide_char);
   }
 }
 
@@ -124,10 +124,10 @@ size_t FlightSqlResultSet::Move(size_t rows, size_t bind_offset, size_t bind_typ
 
     for (auto& column : columns_) {
       // There can be unbound columns.
-      if (!column.is_bound_) continue;
+      if (!column.is_bound) continue;
 
       auto* accessor = column.GetAccessorForBinding();
-      ColumnBinding shifted_binding = column.binding_;
+      ColumnBinding shifted_binding = column.binding;
       uint16_t* shifted_row_status_array =
           row_status_array ? &row_status_array[fetched_rows] : nullptr;
 
@@ -267,14 +267,14 @@ void FlightSqlResultSet::BindColumn(int column_n, int16_t target_type, int preci
                                     ssize_t* str_len_buffer) {
   auto& column = columns_[column_n - 1];
   if (buffer == nullptr) {
-    if (column.is_bound_) {
+    if (column.is_bound) {
       num_binding_--;
     }
     column.ResetBinding();
     return;
   }
 
-  if (!column.is_bound_) {
+  if (!column.is_bound) {
     num_binding_++;
   }
 

cpp/src/arrow/flight/sql/odbc/flight_sql/flight_sql_result_set_column.cc

@@ -50,41 +50,41 @@ std::unique_ptr<Accessor> FlightSqlResultSetColumn::CreateAccessor(
 Accessor* FlightSqlResultSetColumn::GetAccessorForTargetType(CDataType target_type) {
   // Cast the original array to a type matching the target_type.
   if (target_type == odbcabstraction::CDataType_DEFAULT) {
-    target_type = ConvertArrowTypeToC(original_array_->type_id(), use_wide_char_);
+    target_type = ConvertArrowTypeToC(original_array_->type_id(), use_wide_char);
   }
 
   cached_accessor_ = CreateAccessor(target_type);
   return cached_accessor_.get();
 }
 
 FlightSqlResultSetColumn::FlightSqlResultSetColumn(bool use_wide_char)
-    : use_wide_char_(use_wide_char), is_bound_(false) {}
+    : use_wide_char(use_wide_char), is_bound(false) {}
 
 void FlightSqlResultSetColumn::SetBinding(const ColumnBinding& new_binding,
                                           arrow::Type::type arrow_type) {
-  binding_ = new_binding;
-  is_bound_ = true;
+  binding = new_binding;
+  is_bound = true;
 
-  if (binding_.target_type == odbcabstraction::CDataType_DEFAULT) {
-    binding_.target_type = ConvertArrowTypeToC(arrow_type, use_wide_char_);
+  if (binding.target_type == odbcabstraction::CDataType_DEFAULT) {
+    binding.target_type = ConvertArrowTypeToC(arrow_type, use_wide_char);
   }
 
   // Overwrite the binding if the caller is using SQL_C_NUMERIC and has used zero
   // precision if it is zero (this is precision unset and will always fail).
-  if (binding_.precision == 0 &&
-      binding_.target_type == odbcabstraction::CDataType_NUMERIC) {
-    binding_.precision = arrow::Decimal128Type::kMaxPrecision;
+  if (binding.precision == 0 &&
+      binding.target_type == odbcabstraction::CDataType_NUMERIC) {
+    binding.precision = arrow::Decimal128Type::kMaxPrecision;
   }
 
   // Rebuild the accessor and casted array if the target type changed.
   if (original_array_ &&
-      (!cached_casted_array_ || cached_accessor_->target_type_ != binding_.target_type)) {
-    cached_accessor_ = CreateAccessor(binding_.target_type);
+      (!cached_casted_array_ || cached_accessor_->target_type_ != binding.target_type)) {
+    cached_accessor_ = CreateAccessor(binding.target_type);
   }
 }
 
 void FlightSqlResultSetColumn::ResetBinding() {
-  is_bound_ = false;
+  is_bound = false;
   cached_casted_array_.reset();
   cached_accessor_.reset();
 }

cpp/src/arrow/flight/sql/odbc/flight_sql/flight_sql_result_set_column.h

@@ -40,15 +40,15 @@ class FlightSqlResultSetColumn {
   FlightSqlResultSetColumn() = default;
   explicit FlightSqlResultSetColumn(bool use_wide_char);
 
-  ColumnBinding binding_;
-  bool use_wide_char_;
-  bool is_bound_;
+  ColumnBinding binding;
+  bool use_wide_char;
+  bool is_bound;
 
   inline Accessor* GetAccessorForBinding() { return cached_accessor_.get(); }
 
   inline Accessor* GetAccessorForGetData(CDataType target_type) {
     if (target_type == odbcabstraction::CDataType_DEFAULT) {
-      target_type = ConvertArrowTypeToC(original_array_->type_id(), use_wide_char_);
+      target_type = ConvertArrowTypeToC(original_array_->type_id(), use_wide_char);
     }
 
     if (cached_accessor_ && cached_accessor_->target_type_ == target_type) {
@@ -65,8 +65,8 @@ class FlightSqlResultSetColumn {
     original_array_ = std::move(array);
     if (cached_accessor_) {
       cached_accessor_ = CreateAccessor(cached_accessor_->target_type_);
-    } else if (is_bound_) {
-      cached_accessor_ = CreateAccessor(binding_.target_type);
+    } else if (is_bound) {
+      cached_accessor_ = CreateAccessor(binding.target_type);
     } else {
       cached_casted_array_.reset();
       cached_accessor_.reset();

cpp/src/arrow/flight/sql/odbc/flight_sql/flight_sql_result_set_metadata.cc

@@ -68,7 +68,7 @@ size_t FlightSqlResultSetMetadata::GetPrecision(int column_position) {
 
   int32_t column_size = GetFieldPrecision(field).ValueOrElse([] { return 0; });
   SqlDataType data_type_v3 =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
 
   return GetColumnSize(data_type_v3, column_size).value_or(0);
 }
@@ -79,15 +79,15 @@ size_t FlightSqlResultSetMetadata::GetScale(int column_position) {
 
   int32_t type_scale = metadata.GetScale().ValueOrElse([] { return 0; });
   SqlDataType data_type_v3 =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
 
   return GetTypeScale(data_type_v3, type_scale).value_or(0);
 }
 
 uint16_t FlightSqlResultSetMetadata::GetDataType(int column_position) {
   const std::shared_ptr<Field>& field = schema_->field(column_position - 1);
   const SqlDataType concise_type =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
   return GetNonConciseDataType(concise_type);
 }
 
@@ -126,10 +126,10 @@ std::string FlightSqlResultSetMetadata::GetColumnLabel(int column_position) {
 size_t FlightSqlResultSetMetadata::GetColumnDisplaySize(int column_position) {
   const std::shared_ptr<Field>& field = schema_->field(column_position - 1);
 
-  int32_t column_size = metadata_settings_.string_column_length_.value_or(
+  int32_t column_size = metadata_settings_.string_column_length.value_or(
       GetFieldPrecision(field).ValueOr(DefaultLengthForVariableLengthColumns));
   SqlDataType data_type_v3 =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
 
   return GetDisplaySize(data_type_v3, column_size).value_or(odbcabstraction::NO_TOTAL);
 }
@@ -148,17 +148,17 @@ uint16_t FlightSqlResultSetMetadata::GetConciseType(int column_position) {
   const std::shared_ptr<Field>& field = schema_->field(column_position - 1);
 
   const SqlDataType sqlColumnType =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
   return sqlColumnType;
 }
 
 size_t FlightSqlResultSetMetadata::GetLength(int column_position) {
   const std::shared_ptr<Field>& field = schema_->field(column_position - 1);
 
-  int32_t column_size = metadata_settings_.string_column_length_.value_or(
+  int32_t column_size = metadata_settings_.string_column_length.value_or(
       GetFieldPrecision(field).ValueOr(DefaultLengthForVariableLengthColumns));
   SqlDataType data_type_v3 =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
 
   return flight_sql::GetLength(data_type_v3, column_size)
       .value_or(DefaultLengthForVariableLengthColumns);
@@ -185,7 +185,7 @@ std::string FlightSqlResultSetMetadata::GetLocalTypeName(int column_position) {
 size_t FlightSqlResultSetMetadata::GetNumPrecRadix(int column_position) {
   const std::shared_ptr<Field>& field = schema_->field(column_position - 1);
   SqlDataType data_type_v3 =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
 
   return GetRadixFromSqlDataType(data_type_v3).value_or(odbcabstraction::NO_TOTAL);
 }
@@ -194,10 +194,10 @@ size_t FlightSqlResultSetMetadata::GetOctetLength(int column_position) {
   const std::shared_ptr<Field>& field = schema_->field(column_position - 1);
   arrow::flight::sql::ColumnMetadata metadata = GetMetadata(field);
 
-  int32_t column_size = metadata_settings_.string_column_length_.value_or(
+  int32_t column_size = metadata_settings_.string_column_length.value_or(
       GetFieldPrecision(field).ValueOr(DefaultLengthForVariableLengthColumns));
   SqlDataType data_type_v3 =
-      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char_);
+      GetDataTypeFromArrowFieldV3(field, metadata_settings_.use_wide_char);
 
   // Workaround to get the precision for Decimal and Numeric types, since server doesn't
   // return it currently.

cpp/src/arrow/flight/sql/odbc/flight_sql/flight_sql_statement_get_columns.cc

@@ -113,7 +113,7 @@ Result<std::shared_ptr<RecordBatch>> TransformInner(
       }
 
       odbcabstraction::SqlDataType data_type_v3 =
-          GetDataTypeFromArrowFieldV3(field, metadata_settings.use_wide_char_);
+          GetDataTypeFromArrowFieldV3(field, metadata_settings.use_wide_char);
 
       ColumnMetadata metadata(field->metadata());
 

cpp/src/arrow/flight/sql/odbc/flight_sql/flight_sql_statement_get_type_info.cc

@@ -90,7 +90,7 @@ Result<std::shared_ptr<RecordBatch>> TransformInner(
   while (reader.Next()) {
     auto data_type_v3 = EnsureRightSqlCharType(
         static_cast<odbcabstraction::SqlDataType>(reader.GetDataType()),
-        metadata_settings_.use_wide_char_);
+        metadata_settings_.use_wide_char);
     int16_t data_type_v2 = ConvertSqlDataTypeFromV3ToV2(data_type_v3);
 
     if (data_type != odbcabstraction::ALL_TYPES && data_type_v3 != data_type &&
@@ -126,7 +126,7 @@ Result<std::shared_ptr<RecordBatch>> TransformInner(
     data.maximum_scale = reader.GetMaximumScale();
     data.sql_data_type = GetNonConciseDataType(EnsureRightSqlCharType(
         static_cast<odbcabstraction::SqlDataType>(reader.GetSqlDataType()),
-        metadata_settings_.use_wide_char_));
+        metadata_settings_.use_wide_char));
     data.sql_datetime_sub =
         GetSqlDateTimeSubCode(static_cast<odbcabstraction::SqlDataType>(data.data_type));
     data.num_prec_radix = reader.GetNumPrecRadix();

cpp/src/arrow/flight/sql/odbc/flight_sql/include/flight_sql/config/configuration.h

@@ -66,7 +66,7 @@ class Configuration {
   std::vector<std::string> GetCustomKeys() const;
 
  private:
-  driver::odbcabstraction::Connection::ConnPropertyMap properties;
+  driver::odbcabstraction::Connection::ConnPropertyMap properties_;
 };
 
 }  // namespace config

cpp/src/arrow/flight/sql/odbc/flight_sql/include/flight_sql/config/connection_string_parser.h

@@ -70,7 +70,7 @@ class ConnectionStringParser {
   ConnectionStringParser& operator=(const ConnectionStringParser&) = delete;
 
   /** Configuration. */
-  Configuration& cfg;
+  Configuration& cfg_;
 };
 
 }  // namespace config

cpp/src/arrow/flight/sql/odbc/flight_sql/include/flight_sql/ui/add_property_window.h

@@ -85,32 +85,32 @@ class AddPropertyWindow : public CustomWindow {
 
   void CheckEnableOk();
 
-  std::vector<std::unique_ptr<Window> > labels;
+  std::vector<std::unique_ptr<Window> > labels_;
 
   /** Ok button. */
-  std::unique_ptr<Window> ok_button;
+  std::unique_ptr<Window> ok_button_;
 
   /** Cancel button. */
-  std::unique_ptr<Window> cancel_button;
+  std::unique_ptr<Window> cancel_button_;
 
-  std::unique_ptr<Window> key_edit;
+  std::unique_ptr<Window> key_edit_;
 
-  std::unique_ptr<Window> value_edit;
+  std::unique_ptr<Window> value_edit_;
 
-  std::wstring key;
+  std::wstring key_;
 
-  std::wstring value;
+  std::wstring value_;
 
   /** Window width. */
-  int width;
+  int width_;
 
   /** Window height. */
-  int height;
+  int height_;
 
   /** Flag indicating whether OK option was selected. */
-  bool accepted;
+  bool accepted_;
 
-  bool is_initialized;
+  bool is_initialized_;
 };
 
 }  // namespace config