query/include/matador/object/attribute.hpp

#ifndef QUERY_COLUMN_DEFINITION_HPP
#define QUERY_COLUMN_DEFINITION_HPP

#include "matador/utils/basic_types.hpp"
#include "matador/utils/default_type_traits.hpp"
#include "matador/utils/field_attributes.hpp"

#include <memory>

namespace matador::object {

enum class null_option_type : uint8_t {
  NULLABLE, NOT_NULL
};

struct attribute_options {
  utils::field_attributes attributes;
  null_option_type null_option{null_option_type::NOT_NULL};
  int index{-1};
};
class object;
class attribute_generator;

class attribute {
public:
  explicit attribute(std::string name); // NOLINT(*-explicit-constructor)

  attribute(const attribute&) = default;
  attribute& operator=(const attribute&) = default;
  attribute(attribute&&) noexcept = default;
  attribute& operator=(attribute&&) noexcept = default;

  attribute() = default;
  attribute(std::string name,
            utils::basic_type type,
            const utils::field_attributes&,
            null_option_type null_opt);

  [[nodiscard]] const std::string& name() const;
  void name(const std::string& n);
  [[nodiscard]] std::string full_name() const;
  [[nodiscard]] int index() const;
  [[nodiscard]] const utils::field_attributes& attributes() const;
  [[nodiscard]] utils::field_attributes& attributes();
  [[nodiscard]] bool is_nullable() const;
  [[nodiscard]] utils::basic_type type() const;
  [[nodiscard]] object* owner() const;
  // [[nodiscard]] const std::string& table_name() const;
  // void table_name(const std::string& name);
  void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::null_attributes);
  template < typename Type >
  void change_type(const utils::field_attributes &attr = utils::null_attributes) {
      type_ = utils::data_type_traits<Type>::type(attr.size());
  }

  [[nodiscard]] bool is_integer() const;
  [[nodiscard]] bool is_floating_point() const;
  [[nodiscard]] bool is_bool() const;
  [[nodiscard]] bool is_string() const;
  [[nodiscard]] bool is_varchar() const;
  [[nodiscard]] bool is_date() const;
  [[nodiscard]] bool is_time() const;
  [[nodiscard]] bool is_blob() const;
  [[nodiscard]] bool is_null() const;

  template< typename Type >
  [[nodiscard]] bool is_type_of() const {
    return type() == utils::data_type_traits<Type>::type(attributes().size());
  }

private:
  friend class object;
  friend class attribute_generator;

  std::string name_;
  object *owner_{nullptr};
  attribute_options options_;
  utils::basic_type type_{utils::basic_type::type_null};
};


/**
 * User defined literal to have a shortcut creating a column object
 * @param name Name of the column
 * @param type
 * @param attr Length of the column name
 * @param null_opt
 * @return A column object with a given name
 */
// attribute make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL);
//
// template < typename Type >
// attribute make_column(const std::string &name, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL)
// {
//     return make_column(name, utils::data_type_traits<Type>::type(0), attr, null_opt);
// }
// template <>
// attribute make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option_type null_opt);
//
// template < typename Type >
// attribute make_pk_column(const std::string &name, size_t size = 0)
// {
//     return make_column<Type>(name, { size, utils::constraints::PrimaryKey });
// }
//
// template <>
// attribute make_pk_column<std::string>(const std::string &name, size_t size);
//
// template < typename Type >
// attribute make_fk_column(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column) {
//     return {name, utils::data_type_traits<Type>::type(size), ref_column, { size, utils::constraints::ForeignKey }};
// }
//
// template < typename Type >
// [[maybe_unused]] attribute make_fk_column(const std::string &name, const std::shared_ptr<attribute> &ref_column)
// {
//     return {name, utils::data_type_traits<Type>::type(0), 0, ref_column, { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL};
// }
//
// template <>
// [[maybe_unused]] attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column);
//
// template < typename Type >
// [[maybe_unused]] attribute make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name) {
//   return {
//     name, utils::data_type_traits<Type>::type(size), 0,
//     std::make_shared<attribute>(ref_column_name, ref_table_name, utils::data_type_traits<Type>::type(size), utils::constraints::ForeignKey),
//     { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
//   };
// }
//
// template < typename Type >
// [[maybe_unused]] attribute make_fk_column(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name) {
//   return {
//     name, utils::data_type_traits<Type>::type(0), 0,
//     std::make_shared<attribute>(ref_column_name, utils::data_type_traits<Type>::type(0), ref_table_name, attribute_options{utils::constraints::ForeignKey}),
//     { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
//   };
// }
//
// template <>
// [[maybe_unused]] attribute make_fk_column<std::string>(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name);
//
// template <>
// [[maybe_unused]] attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name);

}

#endif //QUERY_COLUMN_DEFINITION_HPP