Here is a list of all namespaces with brief descriptions:

[detail level 1234]

▼Nrelx	Relx database connection
►Nconnection
Nsql_utils
►CAsyncStreamingResultSet	Async streaming result set that yields rows asynchronously
Casync_streaming_iterator	Iterator that reads data on demand asynchronously
CConnection	Abstract base class for database connections
CConnectionError	Error type for database connection operations
CConnectionPoolError	Error type for connection pool operations
Cis_awaitable	Helper trait to detect if a type is boost::asio::awaitable
Cis_awaitable< boost::asio::awaitable< T > >
CPostgreSQLAsyncConnection	Asynchronous PostgreSQL implementation of the Connection interface
CPostgreSQLAsyncStreamingSource	Async PostgreSQL streaming data source for processing large result sets
CPostgreSQLConnection	PostgreSQL implementation of the Connection interface
CPostgreSQLConnectionParams	Basic parameters for a PostgreSQL connection
►CPostgreSQLConnectionPool	PostgreSQL connection pool that manages a collection of PostgreSQL connections
CPooledConnection	A wrapper for a connection that automatically returns it to the pool
CPostgreSQLConnectionPoolConfig	Configuration for PostgreSQL connection pool
CPostgreSQLError	Specialized ConnectionError for PostgreSQL with detailed error information
CPostgreSQLStatement	Represents a prepared statement in PostgreSQL
CPostgreSQLStreamingSource	PostgreSQL streaming data source for processing large result sets
CTransactionException	Exception thrown when transaction operations fail
CTransactionGuard	RAII wrapper for database transactions
Ndetail
Nliterals
►Nmigrations
►Ncli
CCommandLineArgs	Command-line argument parsing result
CAddColumnOperation	ADD COLUMN migration operation
CAddColumnOperation< ColumnMetadata >	Specialized AddColumnOperation for ColumnMetadata
CAddConstraintOperation	ADD CONSTRAINT migration operation
CColumnMetadata	Metadata about a column extracted from PFR analysis
CConstraintMetadata	Metadata about a constraint extracted from PFR analysis
CCreateTableOperation	CREATE TABLE migration operation
CDropColumnOperation	DROP COLUMN migration operation
CDropColumnOperation< ColumnMetadata >	Specialized DropColumnOperation for ColumnMetadata
CDropConstraintOperation	DROP CONSTRAINT migration operation
CDropTableOperation	DROP TABLE migration operation
CMigration	Container for migration operations
CMigrationError	Error information for migration operations
CMigrationOperation	Base class for migration operations
CMigrationOptions	Options for controlling migration generation
CModifyColumnOperation	MODIFY COLUMN migration operation
CRenameColumnOperation	RENAME COLUMN migration operation
CRenameConstraintOperation	RENAME CONSTRAINT migration operation
CTableMetadata	Complete metadata about a table
CUpdateDataOperation	UPDATE DATA migration operation for column transformations
►Npgsql_async_wrapper
CConnection
CPgError
CPreparedStatement
CResult
►Nquery
►Naggregate_checking	Type checking concepts for aggregate functions
Cextract_column_type	Helper to extract column type for checking
Cextract_column_type< schema::column< TableT, Name, ColumnT, Modifiers... > >
RSummable	Concept for numeric types suitable for SUM and AVG
RCountable	Concept for types suitable for COUNT (any type is countable)
RComparable	Concept for comparable types suitable for MIN/MAX
►Narithmetic_checking	Type checking for arithmetic operations
Cextract_arithmetic_type	Helper to extract column type for arithmetic checking
Cextract_arithmetic_type< schema::column< TableT, Name, ColumnT, Modifiers... > >
Cremove_optional	Helper to extract base type from optional
Cremove_optional< std::optional< T > >
RArithmetic	Concept for numeric types suitable for arithmetic operations
►Ndate_checking	Type checking concepts for date/time operations
Cextract_column_type	Helper to extract column type for checking
Cextract_column_type< schema::column< TableT, Name, ColumnT, Modifiers... > >
Cis_time_point	Helper to check if a type is a time_point of any clock
Cis_time_point< std::chrono::time_point< Clock, Duration > >
Cremove_optional	Remove optional wrapper to get base type
Cremove_optional< std::optional< T > >
RDateTimeType	Check if a type is a date/time type
RDateTimeColumn	Check if type is a date/time type (unwrapping optional)
Nliterals	Literals namespace for SQL value literals
►Nmeta
Cis_specialization
Cis_specialization< Template< Args... >, Template >
CAliasedColumn	Column with an alias
CArithmeticExpr	Binary arithmetic expression
CAscendingExpr	Helper for creating an ascending order by expression
CBetweenCondition	BETWEEN condition (col BETWEEN lower AND upper)
CBinaryCondition	Generic binary condition expression
CBinaryDateFunctionExpr	Binary date function expression (e.g., DATE_DIFF)
CCaseExpr
Cclass_of_t	Helper to extract class type from a member pointer
Cclass_of_t< T Class::* >
CCoalesceExpr	COALESCE function
Ccolumn_type_of	Helper to extract column type from member pointer
CColumnExpression	Base class for column expressions
CColumnRef	Column reference expression
CCountAllExpr	Expression representing COUNT(*) in SQL
CCurrentDateTimeExpr	Current date/time functions (no arguments)
CDateArithmeticExpr	Date addition/subtraction expression
CDeleteQuery	Base DELETE query builder
CDescendingExpr	Helper for creating a descending order by expression
CDistinctExpr	DISTINCT qualifier for an expression
CFunctionExpr	Base class for SQL function expressions
CInCondition	Original IN condition for backward compatibility
CInsertItem	Represents a single column-value pair for an INSERT statement
CInsertQuery	Base INSERT query builder
CIntervalExpr	Date interval expression for date arithmetic
CIsNotNullCondition	IS NOT NULL condition
CIsNullCondition	IS NULL condition
CJoinSpec	Relx Query Module
CLikeCondition	LIKE condition (col LIKE pattern)
CNotCondition	Negation condition (NOT expr)
CNullaryFunctionExpr	Base class for SQL function expressions with no arguments
CQueryError	Error type for query operations
CSchemaColumnAdapter	Adapter to convert schema::column to a ColumnRef This allows direct use of schema columns in query expressions
CSchemaTableAdapter	Adapter to convert schema::table to work with query builder This maintains table name and enables column access with SQL expression support
CSelectQuery	Base SELECT query builder
CSetItem	Represents a SET clause assignment in an UPDATE statement
CSqlExpression	Base class for SQL expressions
CTypedCaseBuilder
CTypedInCondition	IN condition (col IN (values)) with type checking
CUnaryDateFunctionExpr	Unary date function expression with unit (e.g., EXTRACT)
CUpdateQuery	Base UPDATE query builder
CValue	Represents a literal value in a SQL query
CValue< const char * >	Specialization for C-style string literals (const char*)
CValue< std::optional< T > >	Specialization for std::optional values
CValue< std::string >	Specialization for std::string values
CValue< std::string_view >	Specialization for std::string_view values
RSqlExpr	Concept for SQL expression components
RTableType	Concept for database table types
RColumnType	Concept for column types
RColumnList	Concept for a sequence of column references
RTableList	Concept for a sequence of table references
RConditionExpr	Concept for a condition expression
►Nresult
CCell	Represents a single cell value from a database result
Ccolumn_member_value	Helper to get the value type from a column member pointer
CLazyCell	Lazy cell that defers parsing until accessed
►CLazyResultSet	Lazy result set that defers row parsing until accessed
Citerator	Iterator for lazy rows
CLazyRow	Lazy row that defers cell parsing until accessed
CResultError	Error type for result processing operations
CResultSet	Represents the result set from a database query
CRow	Represents a single row from a database result
CRowAdapter	Class to support structured binding for ResultSet
CRowIterator	Iterator that yields RowAdapters
CRowsView	View class for structured binding support
►CStreamingResultSet	Streaming result set for very large datasets
Cstreaming_iterator	Iterator that reads data on demand
►Nschema
Cautoincrement	AUTOINCREMENT constraint
Ccheck	CHECK constraint
Ccolumn	Represents a column in a database table
Ccolumn< TableT, Name, std::optional< T >, Modifiers... >
Ccolumn_check_constraint	Check constraint explicitly associated with a column
Ccolumn_traits	Contains schema definition components
Ccolumn_traits< bool >
Ccolumn_traits< double >
Ccolumn_traits< float >
Ccolumn_traits< int >
Ccolumn_traits< long >
Ccolumn_traits< long long >
Ccolumn_traits< std::chrono::system_clock::time_point >	Column traits for std::chrono::system_clock::time_point
Ccolumn_traits< std::chrono::year_month_day >	Column traits for std::chrono::year_month_day
Ccolumn_traits< std::nullopt_t >
Ccolumn_traits< std::optional< T > >
Ccolumn_traits< std::string >
Ccomposite_foreign_key	Represents a composite foreign key constraint with multiple columns
Ccomposite_index	Represents a composite index on multiple columns
Ccomposite_primary_key	Represents a composite primary key constraint on multiple columns
Ccomposite_unique_constraint	Represents a composite UNIQUE constraint on multiple columns
Ccreate_table	Generate CREATE TABLE SQL statement for a table struct
Cdefault_value	DEFAULT value for non-string values
Cdrop_table	Generate DROP TABLE SQL statement for a table struct
Cfixed_string	Compile-time string type that can be used as template non-type parameter in C++20
Cfk_impl
Cfk_impl< std::tuple< std::integral_constant< decltype(LocalColumns), LocalColumns >... >, std::tuple< std::integral_constant< decltype(ReferencedColumns), ReferencedColumns >... > >
Cforeign_key	Represents a foreign key constraint on a table
Cidentity	IDENTITY constraint with configurable options
Cindex	Represents an index on a table
Cis_default_value_specialization
Cis_default_value_specialization< default_value< Value > >
Cis_string_default_specialization
Cis_string_default_specialization< string_default< Value, IsLiteral > >
Cmember_pointer_class	Helper to extract the class type from a member pointer
Cmember_pointer_class< T C::* >	Specialization for extracting class type from member pointer
Cmember_pointer_type	Helper to extract the member type from a member pointer
Cmember_pointer_type< T C::* >	Specialization for extracting member type from member pointer
Cnull_default	NULL default for optional types
Con_delete	ON DELETE action for foreign keys
Con_update	ON UPDATE action for foreign keys
Cpack_element
Cpack_element< 0, First, Rest... >
Cpack_element< N, First, Rest... >
Cprimary_key	PRIMARY KEY constraint
Creferences	REFERENCES constraint for foreign keys
Cstring_default	DEFAULT value for string literals
Ctable_check_constraint	Check constraint that accepts a condition string at compile time
Ctable_primary_key	Represents a primary key constraint on a table
Cunique	UNIQUE constraint
Cunique_constraint	Represents a UNIQUE constraint on a table
RValidIdentityType	Concept for valid identity types
RColumnTypeConcept
Ris_column	Helper to detect column members in a table
RTableConcept	Concept for a database table type
Ris_constraint	Helper to detect constraint members in a table
►Ntype_checking	Type compatibility utilities for column comparisons
Cremove_optional	Helper to extract the underlying type from optional
Cremove_optional< std::optional< T > >
RStringCompatible	Check if two types are string-compatible
ROptionalCompatible	Check if optional types are compatible with each other or their underlying types
RTypeCompatible	Check if column type is compatible with value type
CRelxException	Base exception class for relx errors
Nstd	STL namespace