datum.h

Go to the documentation of this file.

 
namespace taco {
 
namespace datum_impl {
 
typedef uintptr_t DatumRep;
static_assert(sizeof(DatumRep) == 8, "Pointers are not 64-bit.");
 
union DatumFloatConversion {
    int32_t     int32_v;
    float       float_v;
};
 
union DatumDoubleConversion {
    int64_t     int64_v;
    double      double_v;
};
 
template<class DatumImpl>
class NonVarlenGetters {
public:
    constexpr const char*
    GetFixedlenBytes() const {
        return (const char*) &val();
    }
 
    constexpr bool
    GetBool() const {
        return ((bool) ((val()) != 0));
    }
 
    constexpr char
    GetChar() const {
        return ((char) (val()));
    }
 
    constexpr int8_t
    GetInt8() const {
        return ((int8_t) (val()));
    }
 
    constexpr uint8_t
    GetUInt8() const {
        return ((uint8_t) (val()));
    }
 
    constexpr int16_t
    GetInt16() const {
        return ((int16_t) (val()));
    }
 
    constexpr uint16_t
    GetUInt16() const {
        return ((uint16_t) (val()));
    }
 
    constexpr int32_t
    GetInt32() const {
        return ((int32_t) (val()));
    }
 
    constexpr uint32_t
    GetUInt32() const {
        return ((uint32_t) (val()));
    }
 
    constexpr Oid
    GetOid() const {
        return ((Oid) (val()));
    }
 
    constexpr int64_t
    GetInt64() const {
        return (int64_t) val();
    }
 
    constexpr uint64_t
    GetUInt64() const {
        return (uint64_t) val();
    }
 
    constexpr float
    GetFloat() const {
        return datum_impl::DatumFloatConversion{.int32_v=GetInt32()}.float_v;
    }
 
    constexpr double
    GetDouble() const {
        return datum_impl::DatumDoubleConversion{.int64_v=GetInt64()}.double_v;
    }
 
    constexpr void*
    GetPointer() const {
        return ((void*) (val()));
    }
 
    template<class T>
    constexpr T*
    GetPointerAs() const {
        return reinterpret_cast<T* const>(val());
    }
 
protected:
    constexpr const DatumRep&
    val() const {
        return static_cast<const DatumImpl&>(*this).m_val;
    }
};
 
template<class DatumImpl>
class DatumRefVarlenGetters;
 
}   // namespace datum_impl
 
class Datum: public datum_impl::NonVarlenGetters<Datum> {
public:
    ~Datum() {
        if (m_isowned) {
            free(GetPointer());
        }
    }
 
    Datum(Datum &&d) {
        memcpy(this, &d, sizeof(Datum));
 
        // GCC >=8 complains about clearing an object with no trivial
        // copy-assignment. It should be Ok here, since we are transferring
        // the ownership from d to this.
#if __GNUC__ >= 8
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
        memset(&d, 0, sizeof(Datum));
#if __GNUC__ >= 8
#pragma GCC diagnostic pop
#endif
        d.m_isnull = true;
    }
 
    Datum &operator=(Datum &&d) {
        if (m_isowned) {
            free(GetPointer());
        }
        memcpy(this, &d,  sizeof(Datum));
 
        // same as above in Datum(Datum&&)
#if __GNUC__ >= 8
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wclass-memaccess"
#endif
        memset(&d, 0, sizeof(Datum));
#if __GNUC__ >= 8
#pragma GCC diagnostic pop
#endif
        d.m_isnull = true;
        return *this;
    }
 
    bool
    isnull() const {
        return m_isnull;
    }
 
    char*
    GetVarlenBytes() const {
        return (char *) m_val;
    }
 
    uint32_t
    GetVarlenSize() const {
        return m_size;
    }
 
    /*
     * Returns the variable-length value of a datum as an absl::string_view.
     *
     * This is equivalent to absl::string_view(GetVarlenBytes(),
     * GetVarlenSize()).
     */
    absl::string_view
    GetVarlenAsStringView() const {
        return absl::string_view((const char *) m_val, m_size);
    }
 
    const Datum&
    GetThis() const {
        return *this;
    }
 
    /*
     * Returns datum representation of a null value.
     */
    static Datum
    FromNull() {
        return Datum();
    }
 
    static Datum
    From(bool X) {
        return Datum((datum_impl::DatumRep) ((X) ? 1 : 0));
    }
 
    static Datum
    From(char X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(int8_t X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(uint8_t X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(int16_t X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(uint16_t X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(int32_t X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(uint32_t X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(void *X) {
        return Datum((datum_impl::DatumRep) (X));
    }
 
    static Datum
    From(int64_t X) {
        return Datum((datum_impl::DatumRep) X);
    }
 
    static Datum
    From(uint64_t X) {
        return Datum((datum_impl::DatumRep) X);
    }
 
 
    static Datum
    From(float X) {
        return datum_impl::DatumFloatConversion{.float_v=X}.int32_v;
    }
 
    static Datum
    From(double X) {
        return datum_impl::DatumDoubleConversion{.double_v=X}.int64_v;
    }
 
    static Datum
    FromCString(const char *str) {
        size_t len = std::strlen(str);
        if (len > std::numeric_limits<uint32_t>::max()) {
            LOG(kFatal, "cstring is too long: %lu", len);
        }
        return FromVarlenBytes(str, len);
    }
 
    /*
     * Returns datum representation of a null-terminated string that is not
     * owned by this datum if isnull is false, or otherwise, returns a datum of
     * a null value. A null-terminated string is always treated as
     * a variable-length datum so you have to call GetVarlenAsStringView() to
     * convert it back to a string (though there is no guarantee that the
     * returned string_view has a pointer to a null-terminated string).
     */
    static Datum
    FromCString(const char *str, bool isnull) {
        return isnull ? Datum() : FromCString(str);
    }
 
    static Datum
    FromCString(std::unique_ptr<char[]> str, bool isnull = false) {
        if (isnull || !str.get())
            return Datum();
        size_t len = std::strlen(str.get());
        if (len > std::numeric_limits<uint32_t>::max()) {
            LOG(kFatal, "cstring is too long: %lu", len);
        }
        return Datum((datum_impl::DatumRep) str.release(), true, len);
    }
 
    static Datum
    FromVarlenBytes(const char *bytes, uint32_t size) {
        return Datum((datum_impl::DatumRep) bytes, false, size);
    }
 
    static Datum
    FromVarlenBytes(const char *bytes, uint32_t size, bool isnull) {
        return isnull ? Datum() : FromVarlenBytes(bytes, size);
    }
 
    static Datum
    FromVarlenBytes(unique_malloced_ptr bytes, uint32_t size,
                    bool isnull = false) {
        if (!bytes.get() || isnull) {
            return Datum();
        }
        return Datum((datum_impl::DatumRep) bytes.release(), true, size);
    }
 
    static Datum
    FromVarlenAsStringView(absl::string_view bytes) {
        if (!bytes.data())
            return Datum();
        return FromVarlenBytes(bytes.data(), bytes.size());
    }
 
    template<class T>
    static Datum
    From(T&& X, bool isnull) {
        return isnull ? Datum() : From(std::forward<T>(X));
    }
 
    static Datum
    FromFixedlenBytes(const char *bytes, uint32_t size) {
        //ASSERT(TYPEALIGN(size, (uintptr_t) bytes) == (uintptr_t) bytes);
 
        switch (size) {
        case 1:
            return Datum((datum_impl::DatumRep)*(uint8_t*)bytes);
        case 2:
            return Datum((datum_impl::DatumRep)*(uint16_t*)bytes);
        case 4:
            return Datum((datum_impl::DatumRep)*(uint32_t*)bytes);
        case 8:
            return Datum((datum_impl::DatumRep)*(uint64_t*)bytes);
        }
 
        LOG(kError, "unexpected pass-by-value data length %u", size);
        return Datum();
    }
 
    bool
    HasExternalRef() const {
        return m_isvarlen && !m_isowned;
    }
 
    Datum
    DeepCopy() const {
        if (m_isvarlen) {
            const char *bytes = GetVarlenBytes();
            size_t size = GetVarlenSize();
            // We don't know what exactly the alignment requirement is, so
            // make it the maximum a type might need.
            unique_malloced_ptr bytes_copy = unique_aligned_alloc(8, size);
            memcpy(bytes_copy.get(), bytes, size);
            return Datum::FromVarlenBytes(std::move(bytes_copy), size);
        }
        return Copy();
    }
 
    Datum
    Copy() const {
        if (m_isvarlen && m_isowned) {
            // make sure it is not owned in the shallow copy.
            return Datum::FromVarlenBytes(GetVarlenBytes(), GetVarlenSize());
        }
        return Datum(*this);
    }
 
private:
    Datum():
        m_isowned(false),
        m_isnull(true),
        m_isvarlen(false),
        m_size(0),
        m_val(0) {}
 
    Datum(datum_impl::DatumRep value):
        m_isowned(false),
        m_isnull(false),
        m_isvarlen(false),
        m_size(0),
        m_val(value) {}
 
    /*Datum(datum_impl::DatumRep value, bool isowned):
        m_isowned(isowned),
        m_isnull(false),
        m_isvarlen(false),
        m_size(0),
        m_val(value) {} */
 
    Datum(datum_impl::DatumRep value,
          bool isowned,
          uint32_t size):
        m_isowned(isowned),
        m_isnull(false),
        m_isvarlen(true),
        m_size(size),
        m_val(value) {}
 
    // The default constructor and copy assignment should not be used outside
    // the Datum class.
    Datum(const Datum&) = default;
    Datum &operator=(const Datum&) = default;
 
    bool        m_isowned : 1;
 
    bool        m_isnull : 1;
 
    bool        m_isvarlen : 1;
 
    uint32_t    m_size;
 
    datum_impl::DatumRep    m_val;
 
    template<class DatumImpl>
    friend class datum_impl::NonVarlenGetters;
    template<class DatumImpl>
    friend class datum_impl::DatumRefVarlenGetters;
    friend class DatumRef;
    friend class NullableDatumRef;
    friend struct DataArray;
};
 
namespace datum_impl {
 
template<class DatumImpl>
class DatumRefVarlenGetters: public NonVarlenGetters<DatumImpl> {
public:
 
    constexpr char*
    GetVarlenBytes() const {
        return NonVarlenGetters<DatumImpl>::template GetPointerAs<Datum>()
            ->GetVarlenBytes();
    }
 
    constexpr uint32_t
    GetVarlenSize() const {
        return NonVarlenGetters<DatumImpl>::template GetPointerAs<Datum>()
            ->GetVarlenSize();
    }
 
    /*
     * Returns the variable-length value of a datum as an absl::string_view.
     *
     * This is equivalent to
     * absl::string_view(GetVarlenBytes(), GetVarlenSize()).
     *
     * This is also used for returning a string value but the string is not
     * guaranteed to be null-terminated -- see FromCString() for additional
     * notes.
     */
    constexpr absl::string_view
    GetVarlenAsStringView() const {
        return NonVarlenGetters<DatumImpl>::template GetPointerAs<Datum>()
            ->GetVarlenAsStringView();
    }
 
    constexpr Datum&
    GetDatum() const {
        return *NonVarlenGetters<DatumImpl>::template GetPointerAs<Datum>();
    }
 
    Datum
    DeepCopy(bool isbyref) const {
        if (((DatumImpl&)(*this)).isnull()) {
            return Datum();
        }
        if (isbyref) {
            return GetDatum().DeepCopy();
        } else {
            return Datum(NonVarlenGetters<DatumImpl>::val());
        }
    }
};
 
}   // namespace datum_impl
 
class DatumRef: public datum_impl::DatumRefVarlenGetters<DatumRef> {
public:
    DatumRef(const Datum &d):
        m_val(d.m_isvarlen? ((datum_impl::DatumRep) &d) : d.m_val) {}
    // DatumRef must not have a non-trivial destructor.
 
    DatumRef(const DatumRef &) = default;
    DatumRef &operator=(const DatumRef&) = default;
 
    constexpr bool
    isnull() const {
        return false;
    }
 
protected:
    DatumRef(datum_impl::DatumRep val):
        m_val(val) {}
 
    datum_impl::DatumRep    m_val;
 
    friend class datum_impl::NonVarlenGetters<DatumRef>;
    friend class NullableDatumRef;
};
 
/* Make sure that DatumRef may be passed in a register whenever possible. */
static_assert(sizeof(DatumRef) == sizeof(datum_impl::DatumRep));
 
/*
 * NullableDatumRef additionally stores whether an object is null or not.
 * In some cases, we want to pass the nullness of an object as well, e.g., as
 * arguments to a fmgr-managed function. NullableDatumRef allows for that.
 *
 * Different from DatumRef, the only reason that NullableDatumRef does not just
 * wrap a pointer to a Datum is that we want to have implicit conversion from a
 * DatamRef to a NullableDatumRef, and DatumRef may not be a pointer to a
 * Datum in all cases.
 */
class NullableDatumRef:
    public datum_impl::DatumRefVarlenGetters<NullableDatumRef>  {
public:
    NullableDatumRef(const Datum &d):
        m_isnull(d.m_isnull),
        m_val(d.m_isvarlen? ((datum_impl::DatumRep) &d) : d.m_val) {}
 
    NullableDatumRef(const DatumRef & d):
        m_isnull(false),
        m_val(d.m_val) {}
 
    NullableDatumRef(const NullableDatumRef&) = default;
    NullableDatumRef& operator=(const NullableDatumRef&) = default;
 
    operator DatumRef() const {
        if (m_isnull)
            LOG(kFatal, "casting NULL datum to a DatumRef");
        return DatumRef(m_val);
    }
 
    constexpr bool
    isnull() const {
        return m_isnull;
    }
 
private:
    bool                    m_isnull;
    datum_impl::DatumRep    m_val;
 
    friend class datum_impl::NonVarlenGetters<NullableDatumRef>;
};
 
struct DataArray {
    constexpr static uint32_t VARLEN_MASK = 1u << 31;
 
    static Datum
    From(const Datum *data, uint32_t n) {
        uint32_t total_sz = MAXALIGN(n * sizeof(uint32_t));
        for (size_t i = 0; i < n; ++i) {
            total_sz += data[i].m_isvarlen ? MAXALIGN(data[i].m_size) :
                        (data[i].m_isnull ? 0 :
                          (uint32_t) sizeof(datum_impl::DatumRep));
        }
        unique_malloced_ptr bytes = unique_aligned_alloc(8, total_sz);
        auto off = reinterpret_cast<uint32_t*>(bytes.get());
        off[0] = n;
        uint32_t cur_off = MAXALIGN(n * sizeof(uint32_t));
        auto payload = reinterpret_cast<char*>(bytes.get());
        for (size_t i = 0; i < n; ++i) {
            if (data[i].m_isvarlen) {
                memcpy(payload + cur_off, (const char*) data[i].m_val,
                       data[i].m_size);
                cur_off += MAXALIGN(data[i].m_size);
            } else if (!data[i].m_isnull) {
                *reinterpret_cast<datum_impl::DatumRep*>(payload + cur_off)
                    = data[i].m_val;
                cur_off += sizeof(datum_impl::DatumRep);
            }
            if (i + 1 != n) {
                off[i + 1] = cur_off;
            }
            if (data[i].m_isvarlen) {
                off[i] |= VARLEN_MASK;
            }
        }
        ASSERT(cur_off == total_sz);
        return Datum::FromVarlenBytes(std::move(bytes), total_sz);
    }
 
    template<class SomeDatum>
    static size_t
    GetArrayLength(SomeDatum &&d) {
        return *reinterpret_cast<const uint32_t*>(d.GetVarlenBytes())
                & ~VARLEN_MASK;
    }
 
    template<class SomeDatum>
    static Datum
    GetDatum(SomeDatum &&d, size_t i) {
        uint32_t n = GetArrayLength(d);
        uint32_t off;
        uint32_t end_off;
        if (i == 0) {
            off = MAXALIGN(n * sizeof(uint32_t));
        } else {
            off = reinterpret_cast<const uint32_t*>(d.GetVarlenBytes())[i]
                & ~VARLEN_MASK;
        }
 
        if (i + 1 == n) {
            end_off = d.GetVarlenSize();
        } else {
            end_off = reinterpret_cast<const uint32_t*>(
                d.GetVarlenBytes())[i + 1] & ~VARLEN_MASK;
        }
        if (end_off == off) {
            return Datum::FromNull();
        }
 
        if (VARLEN_MASK &
            reinterpret_cast<const uint32_t*>(d.GetVarlenBytes())[i]) {
            // varlen-value
            return Datum::FromVarlenBytes(d.GetVarlenBytes() + off,
                                          end_off - off);
        } else {
            // fixed-len value
            return Datum::FromFixedlenBytes(d.GetVarlenBytes() + off,
                                            sizeof(datum_impl::DatumRep));
        }
    }
};
 
}   // namespace taco