Hur kan jag hitta DATETIME från MySQL igenom MySQL/Connector C++ 8.0?

std::vector<std::vector<std::string>> getDatabaseValues(const char tableName[]) {
	std::vector<std::string> values;
	std::vector<std::vector<std::string>> table;
	if (isConnectedToDatabase()) {
		// Select only the first row
		std::string query = "SELECT * FROM " + std::string(tableName);
		mysqlx::SqlResult result = connection->sql(query).execute();
		int columnCount = result.getColumnCount();
		if (result.hasData()) {
			mysqlx::Row row;
			while (row = result.fetchOne()) {
				for (int i = 0; i < columnCount; i++) {
					switch (row[i].getType()) {
					case mysqlx::common::Value::UINT64:
						values.push_back(std::to_string(row[i].get<uint64_t>()));
						break;
					case mysqlx::common::Value::INT64:
						values.push_back(std::to_string(row[i].get<int64_t>()));
						break;
					case mysqlx::common::Value::FLOAT:
						values.push_back(std::to_string(row[i].get<float>()));
						break;
					case mysqlx::common::Value::STRING:
						values.push_back(row[i].get<std::string>());
						break;
					case mysqlx::common::Value::RAW:
						mysqlx::bytes bytes = row[i].getRawBytes();
                                                ??? Nu då?
						break;
					}
				}
				table.push_back(values);
			}
		}
	}
	return table;
}

#include "boost/date_time/posix_time/posix_time.hpp"
#include <vector>
#include <cstddef>
#include <chrono>

static inline std::vector<uint64_t> mysqlx_raw_as_u64_vector(const mysqlx::Value& in_value) {
	std::vector<uint64_t> out;

	const auto bytes = in_value.getRawBytes();
	auto ptr = reinterpret_cast<const std::byte*>(bytes.first);
	auto end = reinterpret_cast<const std::byte*>(bytes.first) + bytes.second;

	while (ptr != end) {
		static constexpr std::byte carry_flag{ 0b1000'0000 };
		static constexpr std::byte value_mask{ 0b0111'1111 };

		uint64_t v = 0;
		uint64_t shift = 0;
		bool is_carry;
		do {
			auto byte = *ptr;
			is_carry = (byte & carry_flag) == carry_flag;
			v |= std::to_integer<uint64_t>(byte & value_mask) << shift;

			++ptr;
			shift += 7;
		} while (is_carry && ptr != end && shift <= 63);

		out.push_back(v);
	}

	return out;
}

static inline std::chrono::system_clock::time_point mySQLDateTimeToTimePoint(const mysqlx::Value& value) {
	const auto vector = mysqlx_raw_as_u64_vector(value);
	if (vector.size() < 3)
		throw std::out_of_range{ "Value is not a valid DATETIME" };

	auto ymd = std::chrono::year{ static_cast<int>(vector.at(0)) } / static_cast<int>(vector.at(1)) / static_cast<int>(vector.at(2));
	auto sys_days = std::chrono::sys_days{ ymd };

	auto out = std::chrono::system_clock::time_point(sys_days);

	auto it = vector.begin() + 2;
	auto end = vector.end();

	if (++it == end)
		return out;
	out += std::chrono::hours{ *it };

	if (++it == end)
		return out;
	out += std::chrono::minutes{ *it };

	if (++it == end)
		return out;
	out += std::chrono::seconds{ *it };

	if (++it == end)
		return out;
	out += std::chrono::microseconds{ *it };

	return out;
}

std::string readMySQLDateTimeToString(const mysqlx::Value& value) {
	std::chrono::system_clock::time_point timePoint = mySQLDateTimeToTimePoint(value);
	std::time_t unixTime = std::chrono::system_clock::to_time_t(timePoint);
	
	return "något...";
}

std::time_t unixTime = std::chrono::system_clock::to_time_t(timePoint);

std::chrono::system_clock::time_point timePoint = mySQLDateTimeToTimePoint(value);
std::chrono::system_clock::duration duration = timePoint.time_since_epoch();
int64_t microseconds = duration.count()/10;

case mysqlx::common::Value::RAW:
                        mysqlx::bytes data = row[i].getRawBytes();
                        const mysqlx::byte* first = data.begin();
                        std::vector<int> a;
                        for (int i = 0; i < data.length(); i++)
                            a.push_back(first[i]);
                        a;
                        int month = first[2];
                        int date = first[3];
                        int hour = first[4];
                        int minute = first[5];
                        int second = first[6];


                        values.push_back("YYYY-MM-DDTHH:MM:SS:sss");
                        break;
                    }

(byte[1] << 7 ) | (byte[0] >> 1)

int year = (first[1] << 7) | (first[0] & 0x7f);
int microseconds = (first[9] << 14) | (first[8] << 7) | (first[7] & 0x7f);