Efficiently iterating through a database row (libpqxx), assigning values to a struct

for (auto field : entry)
{
    if (!field.is_null()) record.<if only i could dynamically reference using field.name()> = field.as<somehow magically find appropriate type>();
}

This is entirely feasible, although not quite like this.

Let's just assume we can have some record of what fields driveOperationRecord (henceforth just Record, for brevity) supports, along with their names, and types, and which data member they correspond to. Then we can walk over them, like:

for (auto& field : record_fields)
{
  field.assign(row, record);
}

Now we need some field-describing type like

struct FieldDescriptor
{
  std::string name_;

  void assign(pqxx::row const& row, Record& record)
  {
    auto entry = row[name_];
    if (!entry.is_null()) {
      // do something
    }
  }
};

So far so good. The "do something" step is where we need to use something like virtual dispatch, because we're handling different types.

We could enumerate all the types we care about and write a big switch statement, but it's tedious. I'd start with the simplest thing first, and do something more complex if it turns out you really need it to be faster:

struct FieldDescriptor
{
  std::string name_;
  std::function<void(pqxx::field const&, Record&)> assign_;

  void assign(pqxx::row const& row, Record& record)
  {
    auto entry = row[name_];
    if (!entry.is_null()) {
      assign_(entry, record);
    }
  }
};

OK, so now we just need some way to build a function or callable object similar to

void assignFieldName(pqxx::field const& entry, Record& record) {
    record.fieldName = entry.as<decltype(record.fieldName)>();
}

For example, we could write

template <typename RecordType, typename FieldType>
FieldDescriptor describe(const char *name, FieldType RecordType::*member)
{
    return
    { std::string{name},
      [=member](pqxx::field const& entry, Record& record)
      {
        record.*member = entry.as<FieldType>();
      }
    };
}

and even wrap it up in a macro to save a little more typing:

#define DESCRIBE_RECORD_FIELD(F) describe(#F, &Record:: F)

FieldDescriptor record_fields[] = {
    DESCRIBE_RECORD_FIELD(id),
    DESCRIBE_RECORD_FIELD(drive_operator_id),
    DESCRIBE_RECORD_FIELD(operator_operation_index),
    DESCRIBE_RECORD_FIELD(specific_operation_id),
    DESCRIBE_RECORD_FIELD(operation_outcome),
    DESCRIBE_RECORD_FIELD(error_code),
    DESCRIBE_RECORD_FIELD(operation_seconds),
    DESCRIBE_RECORD_FIELD(operation_date),
    DESCRIBE_RECORD_FIELD(serial_number),
    DESCRIBE_RECORD_FIELD(model),
    DESCRIBE_RECORD_FIELD(size),
    DESCRIBE_RECORD_FIELD(firmware)
};

Now, we have sort of shadowed the whole definition of Record again, which is unfortunate. It's possible to avoid this ... but only by replacing the whole definition with a bunch of macros that do double duty declaring the members, and registering their descriptors.

For a small number of records, I'd probably stick with what we have here. If there are a lot, it's worth making more effort to automate (and to make sure the definition can't get out of sync with the registered descriptors).

If all else fails, you can always go old school to avoid tedious and error prone repetition:

#define ENTRY_TO_RECORD(TYPE) \
  {
    auto e = entry[#NAME]; \
    if (!e.is_null()) {\
      record.NAME = e.as<decltype(NAME)>(); \
    } \
  }

void driveOperationEntryToRecord(pqxx::row entry, driveOperationRecord& record)
{
    try
    {
        ENTRY_TO_RECORD(id);
        ENTRY_TO_RECORD(drive_operator_id);
        ENTRY_TO_RECORD(operator_operation_index);
        ENTRY_TO_RECORD(specific_operation_id);
        ENTRY_TO_RECORD(operation_outcome);
        ENTRY_TO_RECORD(error_code);
        ENTRY_TO_RECORD(operation_seconds);
        ENTRY_TO_RECORD(operation_date);
        ENTRY_TO_RECORD(serial_number);
        ENTRY_TO_RECORD(model);
        ENTRY_TO_RECORD(size);
        ENTRY_TO_RECORD(firmware);
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
}

Yeah, I know this is generally frowned upon, and I should say that there's all sorts of caveats with using precompiler macros (like, don't put them in your header files).

So probably just consider this a temporary workaround while someone comes back with a more idiomatic solution.