foreign_storage::anonymous_namespace{InternalStorageStatsDataWrapper.cpp} Namespace Reference

Functions
void	set_null (import_export::TypedImportBuffer *import_buffer)
void	populate_import_buffers_for_storage_details (const std::vector< StorageDetails > &storage_details, std::map< std::string, import_export::TypedImportBuffer * > &import_buffers)

Function Documentation

void foreign_storage::anonymous_namespace{InternalStorageStatsDataWrapper.cpp}::populate_import_buffers_for_storage_details	(	const std::vector< StorageDetails > &	storage_details,
		std::map< std::string, import_export::TypedImportBuffer * > &	import_buffers
	)

Definition at line 38 of file InternalStorageStatsDataWrapper.cpp.

References foreign_storage::get_db_name(), foreign_storage::get_table_name(), foreign_storage::set_node_name(), and set_null().

Referenced by foreign_storage::InternalStorageStatsDataWrapper::populateChunkBuffersForTable().

                                                                        {
  for (const auto& storage_detail : storage_details) {
    set_node_name(import_buffers);
    if (import_buffers.find("database_id") != import_buffers.end()) {
      import_buffers["database_id"]->addInt(storage_detail.database_id);
    }
    if (import_buffers.find("database_name") != import_buffers.end()) {
      import_buffers["database_name"]->addString(get_db_name(storage_detail.database_id));
    }
    if (import_buffers.find("table_id") != import_buffers.end()) {
      import_buffers["table_id"]->addInt(storage_detail.table_id);
    }
    if (import_buffers.find("table_name") != import_buffers.end()) {
      import_buffers["table_name"]->addString(
          get_table_name(storage_detail.database_id, storage_detail.table_id));
    }
    if (import_buffers.find("epoch") != import_buffers.end()) {
      import_buffers["epoch"]->addInt(storage_detail.storage_stats.epoch);
    }
    if (import_buffers.find("epoch_floor") != import_buffers.end()) {
      import_buffers["epoch_floor"]->addInt(storage_detail.storage_stats.epoch_floor);
    }
    if (import_buffers.find("fragment_count") != import_buffers.end()) {
      auto import_buffer = import_buffers["fragment_count"];
      if (storage_detail.storage_stats.fragment_count.has_value()) {
        import_buffer->addInt(storage_detail.storage_stats.fragment_count.value());
      } else {
        set_null(import_buffer);
      }
    }
    if (import_buffers.find("shard_id") != import_buffers.end()) {
      import_buffers["shard_id"]->addInt(storage_detail.shard_id);
    }
    if (import_buffers.find("data_file_count") != import_buffers.end()) {
      import_buffers["data_file_count"]->addInt(
          storage_detail.storage_stats.data_file_count);
    }
    if (import_buffers.find("metadata_file_count") != import_buffers.end()) {
      import_buffers["metadata_file_count"]->addInt(
          storage_detail.storage_stats.metadata_file_count);
    }
    if (import_buffers.find("total_data_file_size") != import_buffers.end()) {
      import_buffers["total_data_file_size"]->addBigint(
          storage_detail.storage_stats.total_data_file_size);
    }
    if (import_buffers.find("total_data_page_count") != import_buffers.end()) {
      import_buffers["total_data_page_count"]->addBigint(
          storage_detail.storage_stats.total_data_page_count);
    }
    if (import_buffers.find("total_free_data_page_count") != import_buffers.end()) {
      auto import_buffer = import_buffers["total_free_data_page_count"];
      if (storage_detail.storage_stats.total_free_data_page_count.has_value()) {
        import_buffer->addBigint(
            storage_detail.storage_stats.total_free_data_page_count.value());
      } else {
        set_null(import_buffer);
      }
    }
    if (import_buffers.find("total_metadata_file_size") != import_buffers.end()) {
      import_buffers["total_metadata_file_size"]->addBigint(
          storage_detail.storage_stats.total_metadata_file_size);
    }
    if (import_buffers.find("total_metadata_page_count") != import_buffers.end()) {
      import_buffers["total_metadata_page_count"]->addBigint(
          storage_detail.storage_stats.total_metadata_page_count);
    }
    if (import_buffers.find("total_free_metadata_page_count") != import_buffers.end()) {
      auto import_buffer = import_buffers["total_free_metadata_page_count"];
      if (storage_detail.storage_stats.total_free_metadata_page_count.has_value()) {
        import_buffer->addBigint(
            storage_detail.storage_stats.total_free_metadata_page_count.value());
      } else {
        set_null(import_buffer);
      }
    }
    if (import_buffers.find("total_dictionary_data_file_size") != import_buffers.end()) {
      import_buffers["total_dictionary_data_file_size"]->addBigint(
          storage_detail.total_dictionary_data_file_size);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foreign_storage::anonymous_namespace{InternalStorageStatsDataWrapper.cpp}::set_null

(

import_export::TypedImportBuffer *

import_buffer

)

Definition at line 34 of file InternalStorageStatsDataWrapper.cpp.

References import_export::TypedImportBuffer::add_value(), and import_export::TypedImportBuffer::getColumnDesc().

                                                             {
  import_buffer->add_value(import_buffer->getColumnDesc(), "", true, {});
}

Here is the call graph for this function: