// Using explicit type mappings
QUERY(createUser,
    "INSERT INTO users (name, balance, age, is_active) VALUES (:name, :balance, :age, :is_active);",
    PARAM_VARCHAR(name, 255),        // Explicit VARCHAR with length
    PARAM_DECIMAL(balance, 10, 2),   // Explicit DECIMAL with precision and scale
    PARAM_INT(age),                  // Maps to INT
    PARAM_BOOL(is_active))           // Maps to BOOLEAN

/* Define an email field with validation */
DTO_FIELD(Email, email);  // Validates email format and normalizes to lowercase
/* Using the Email wrapper */
Email email("Test@Example.COM");
OATPP_ASSERT(email.normalize() == "test@example.com");  // Normalizes to lowercase
/* Validation with context */
ValidationContext context;
context.isStrict = true;           // Enable strict validation
context.allowNull = false;         // Disallow null values
context.normalizeValues = true;    // Auto-normalize during validation
OATPP_ASSERT(email.validate(context));  // Validates format and normalizes

/* Define a phone field with validation */
DTO_FIELD(PhoneNumber, phone);  // Validates international format
/* Using the PhoneNumber wrapper */
PhoneNumber phone(" +1-555-123-4567 ");
OATPP_ASSERT(phone.normalize() == "+1-555-123-4567");  // Removes whitespace
/* Database operations with type wrappers */
auto row = TypeWrapperRow::createShared();
Email email("Test@Example.com");
PhoneNumber phone("+1-555-123-4567");
row->email = email.toDbValue();     // Stores normalized value
row->phone = phone.toDbValue();     // Stores normalized value
client.insertRow(row);

/* Register flag values */
Flag::registerFlag("READ", 1);
Flag::registerFlag("WRITE", 2);
Flag::registerFlag("EXECUTE", 4);
Flag::registerFlag("ADMIN", 8);
/* Using Flag type in DTO */
DTO_FIELD(Flag, permissions);  // Stores as BIGINT UNSIGNED
/* Basic flag operations */
Flag flags;
flags.setFlag<std::string>("READ");      // Set by name
flags.setFlag<v_uint64>(2);              // Set by value
flags.hasFlag<std::string>("WRITE");     // Check by name
flags.hasFlag<v_uint64>(4);              // Check by value
flags.clearFlag<std::string>("READ");    // Clear by name
flags.toggleFlag<std::string>("ADMIN");  // Toggle by name
/* String conversion */
auto str = flags.toString();             // "WRITE|EXECUTE"
auto flags2 = Flag::fromString(str);     // Parse from string
/* Database operations */
auto row = FlagRow::createShared();
row->permissions = flags.toDbValue();    // Store in database
client.insertRow(row);

class CustomType : public MariaDBTypeWrapper<CustomType, oatpp::String> {
public:
    explicit CustomType(const oatpp::String& value) 
        : MariaDBTypeWrapper<CustomType, oatpp::String>(value) {}
    
    bool validate() const override {
        // Your validation logic
    }
    
    oatpp::String normalize() const override {
        // Your normalization logic
    }
    
    oatpp::String getTypeName() const override {
        return oatpp::String("CustomType");
    }
};

/* Email field with validation constraint */
email VARCHAR(255) NOT NULL CHECK (
    email REGEXP '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
)
/* Phone field with format constraint */
phone VARCHAR(20) NOT NULL CHECK (
    phone REGEXP '^\+[0-9]{1,3}-[0-9]{3}-[0-9]{3}-[0-9]{4}$'
)

/* Using Status type */
Status status = operation.execute();
if (status.isError()) {
    // Handle error case
    auto errorCode = status.code;
    auto message = status.message;
}
/* Predefined status values */
Status::OK();              // Success status
Status::ERROR("message");  // Error status with message

// Define a permission flag with 8 bits
using Permission = oatpp::mariadb::types::Flag<8>;
// Register flags and their values
Permission::registerFlag("READ", 1);
Permission::registerFlag("WRITE", 2);
Permission::registerFlag("EXECUTE", 4);
Permission::registerFlag("ALL", 7);
// Set up flag inheritance (ALL grants READ, WRITE, and EXECUTE)
Permission::registerFlagInheritance("ALL", "READ");
Permission::registerFlagInheritance("ALL", "WRITE");
Permission::registerFlagInheritance("ALL", "EXECUTE");
// Create and manipulate flags
Permission flags;
flags.setFlag("READ");                // Set single flag
flags.setFlagWithInheritance("ALL"); // Set flag and all inherited flags
flags.clearFlag("READ");             // Clear specific flag
flags.toggleFlag("EXECUTE");         // Toggle flag state
// Check flag states
bool canWrite = flags.hasFlag("WRITE");
bool canExecute = flags.hasFlag("EXECUTE");
// Convert to/from string representation
auto str = flags.toString();           // Returns "WRITE|EXECUTE"
auto parsed = Permission::fromString(str);
// Use in DTO
class UserDTO : public oatpp::DTO {
    DTO_INIT(UserDTO, DTO);
    DTO_FIELD(Permission, permissions);
};

auto options = oatpp::mariadb::ConnectionOptions();
options.host = "127.0.0.1";           // Database host
options.port = 3306;                  // Port number
options.username = "user";            // Username
options.password = "password";        // Password
options.database = "test";            // Database name

#include "oatpp-mariadb/orm.hpp"
/* Create connection provider */
auto connectionProvider = std::make_shared<oatpp::mariadb::ConnectionProvider>(options);
/* Create database client */
auto client = MyClient(std::make_shared<oatpp::mariadb::Executor>(connectionProvider));
/* Execute query */
auto result = client.selectAllRows();

#include OATPP_CODEGEN_BEGIN(DTO)
/* Define version tracking DTO */
class SchemaVersionDTO : public oatpp::DTO {
  DTO_INIT(SchemaVersionDTO, DTO)
  DTO_FIELD(oatpp::Int64, version);           // Schema version
  DTO_FIELD(String, name);                    // Migration name
  DTO_FIELD(String, script);                  // Migration script
  DTO_FIELD(String, applied_at);              // Application timestamp
};
#include OATPP_CODEGEN_END(DTO)
/* Create migration table */
QUERY(createSchemaVersionTable,
      "CREATE TABLE IF NOT EXISTS `schema_version` ("
      "  `version` BIGINT NOT NULL,"
      "  `name` VARCHAR(255) NOT NULL,"
      "  `script` TEXT NOT NULL,"
      "  `applied_at` DATETIME DEFAULT CURRENT_TIMESTAMP,"
      "  PRIMARY KEY (`version`)"
      ")")

/* Use TransactionGuard for automatic retry on deadlocks */
{
  auto guard = client.transactionGuard();
  try {
    // Your transaction operations here
    guard.commit();
  } catch (...) {
    guard.rollback();
  }
}

/* Define a product DTO with metadata */
class ProductDTO : public oatpp::DTO {
  DTO_INIT(ProductDTO, DTO)
  DTO_FIELD(String, name);
  DTO_FIELD(Float64, price);
  DTO_FIELD(Object<JsonDTO>, metadata);    // JSON metadata support
};
/* Create with metadata */
QUERY(createProduct,
      "INSERT INTO products (name, price, metadata) "
      "VALUES (:product.name, :product.price, :product.metadata)")
/* Search with filters */
QUERY(findProducts,
      "SELECT * FROM products "
      "WHERE name LIKE :namePattern "
      "AND metadata->>'$.category' = :category")

class TypeTest : public oatpp::test::UnitTest {
private:
    /* Test configuration and setup */
    void onRun() override {
        /* Database connection setup */
        
        /* Test cases */
        testValueMapping();
        testSerialization();
        testDeserialization();
        testEdgeCases();
        
        /* Cleanup */
    }
};