C++ Object Persistence with ODB

source: http://www.codesynthesis.com/products/odb/doc/manual.xhtml#16

C++ Object Persistence with ODB

Copyright © 2009-2013 Code Synthesis Tools CC

Permission is granted to copy, distribute and/or modify this
document under the terms of the
GNU Free
Documentation License, version 1.3; with no Invariant Sections,
no Front-Cover Texts and no Back-Cover Texts.


Revision 2.2, February 2013
This revision of the manual describes ODB 2.2.0 and is available
in the following formats:
XHTML,
PDF, and
PostScript.



Table of Contents



Preface

About This Document
More Information





PART I OBJECT-RELATIONAL MAPPING



1Introduction

1.1Architecture and Workflow
1.2Benefits
1.3Supported C++ Standards





2Hello World Example

2.1Declaring a Persistent Class
2.2Generating Database Support Code
2.3Compiling and Running
2.4Making Objects Persistent
2.5Querying the Database for Objects
2.6Updating Persistent Objects
2.7Defining and Using Views
2.8Deleting Persistent Objects
2.9Accessing Multiple Databases
2.10Summary





3Working with Persistent Objects

3.1Concepts and Terminology
3.2Declaring Persistent Objects and Values
3.3Object and View Pointers
3.4Database
3.5Transactions
3.6Connections
3.7Error Handling and Recovery
3.8Making Objects Persistent
3.9Loading Persistent Objects
3.10Updating Persistent Objects
3.11Deleting Persistent Objects
3.12Executing Native SQL Statements
3.13Tracing SQL Statement Execution
3.14ODB Exceptions





4Querying the Database

4.1ODB Query Language
4.2Parameter Binding
4.3Executing a Query
4.4Query Result
4.5Prepared Queries





5Containers

5.1Ordered Containers
5.2Set and Multiset Containers
5.3Map and Multimap Containers

5.4Change-Tracking Containers

5.4.1Change-Tracking vector



5.5Using Custom Containers





6Relationships


6.1Unidirectional Relationships

6.1.1To-One Relationships
6.1.2To-Many Relationships




6.2Bidirectional Relationships

6.2.1One-to-One Relationships
6.2.2One-to-Many Relationships
6.2.3Many-to-Many Relationships



6.3Circular Relationships
6.4Lazy Pointers
6.5Using Custom Smart Pointers





7Value Types

7.1Simple Value Types

7.2Composite Value Types

7.2.1Composite Object Ids
7.2.2Composite Value Column and Table Names



7.3Pointers and NULL Value Semantics





8Inheritance

8.1Reuse Inheritance

8.2Polymorphism Inheritance

8.2.1Performance and Limitations



8.3Mixed Inheritance





9Views

9.1Object Views
9.2Table Views
9.3Mixed Views
9.4View Query Conditions
9.5Native Views
9.6Other View Features and Limitations





10Session

10.1Object Cache
10.2Custom Sessions





11Optimistic Concurrency



12ODB Pragma Language


12.1Object Type Pragmas

12.1.1table
12.1.2pointer
12.1.3abstract
12.1.4readonly
12.1.5optimistic
12.1.6no_id
12.1.7callback
12.1.8schema
12.1.9polymorphic
12.1.10session
12.1.11definition
12.1.12transient




12.2View Type Pragmas

12.2.1object
12.2.2table
12.2.3query
12.2.4pointer
12.2.5callback
12.2.6definition
12.2.7transient




12.3Value Type Pragmas

12.3.1type
12.3.2id_type
12.3.3null/not_null
12.3.4default
12.3.5options
12.3.6readonly
12.3.7definition
12.3.8transient
12.3.9unordered
12.3.10index_type
12.3.11key_type
12.3.12value_type
12.3.13value_null/value_not_null
12.3.14id_options
12.3.15index_options
12.3.16key_options
12.3.17value_options
12.3.18id_column
12.3.19index_column
12.3.20key_column
12.3.21value_column




12.4Data Member Pragmas

12.4.1id
12.4.2auto
12.4.3type
12.4.4id_type
12.4.5get/set/access
12.4.6null/not_null
12.4.7default
12.4.8options
12.4.9column (object, composite value)
12.4.10column (view)
12.4.11transient
12.4.12readonly
12.4.13virtual
12.4.14inverse
12.4.15version
12.4.16index
12.4.17unique
12.4.18unordered
12.4.19table
12.4.20index_type
12.4.21key_type
12.4.22value_type
12.4.23value_null/value_not_null
12.4.24id_options
12.4.25index_options
12.4.26key_options
12.4.27value_options
12.4.28id_column
12.4.29index_column
12.4.30key_column
12.4.31value_column




12.5Namespace Pragmas

12.5.1pointer
12.5.2table
12.5.3schema
12.5.4session




12.6Index Definition Pragmas


12.7Database Type Mapping Pragmas


12.8C++ Compiler Warnings

12.8.1GNU C++
12.8.2Visual C++
12.8.3Sun C++
12.8.4IBM XL C++
12.8.5HP aC++
12.8.6Clang








13Advanced Techniques and Mechanisms

13.1Transaction Callbacks





PART II DATABASE SYSTEMS



14Multi-Database Support

14.1Static Multi-Database Support

14.2Dynamic Multi-Database Support

14.2.214.2.2 Dynamic Loading of Database Support Code








15MySQL Database


15.1MySQL Type Mapping

15.1.1String Type Mapping
15.1.2Binary Type Mapping



15.2MySQL Database Class
15.3MySQL Connection and Connection Factory
15.4MySQL Exceptions

15.5MySQL Limitations

15.5.1Foreign Key Constraints



15.6MySQL Index Definition





16SQLite Database


16.1SQLite Type Mapping

16.1.1String Type Mapping
16.1.2Binary Type Mapping



16.2SQLite Database Class
16.3SQLite Connection and Connection Factory
16.4SQLite Exceptions

16.5SQLite Limitations

16.5.1Query Result Caching
16.5.2Automatic Assignment of Object Ids
16.5.3Foreign Key Constraints
16.5.4Constraint Violations
16.5.5Sharing of Queries



16.6SQLite Index Definition





17PostgreSQL Database


17.1PostgreSQL Type Mapping

17.1.1String Type Mapping
17.1.2Binary Type and UUID Mapping



17.2PostgreSQL Database Class
17.3PostgreSQL Connection and Connection Factory
17.4PostgreSQL Exceptions

17.5PostgreSQL Limitations

17.5.1Query Result Caching
17.5.2Foreign Key Constraints
17.5.3Unique Constraint Violations
17.5.4Date-Time Format
17.5.5Timezones
17.5.6NUMERIC Type Support



17.6PostgreSQL Index Definition





18Oracle Database


18.1Oracle Type Mapping

18.1.1String Type Mapping
18.1.2Binary Type Mapping



18.2Oracle Database Class
18.3Oracle Connection and Connection Factory
18.4Oracle Exceptions

18.5Oracle Limitations

18.5.1Identifier Truncation
18.5.2Query Result Caching
18.5.3Foreign Key Constraints
18.5.4Unique Constraint Violations
18.5.5Large FLOAT and NUMBER Types
18.5.6Timezones
18.5.7LONG Types
18.5.8LOB Types and By-Value Accessors/Modifiers



18.6Oracle Index Definition





19Microsoft SQL Server Database


19.1SQL Server Type Mapping

19.1.1String Type Mapping
19.1.2Binary Type and UNIQUEIDENTIFIER Mapping
19.1.3ROWVERSION Mapping
19.1.4Long String and Binary Types



19.2SQL Server Database Class
19.3SQL Server Connection and Connection Factory
19.4SQL Server Exceptions

19.5SQL Server Limitations

19.5.1Query Result Caching
19.5.2Foreign Key Constraints
19.5.3Unique Constraint Violations
19.5.4Multi-threaded Windows Applications
19.5.5Affected Row Count and DDL Statements
19.5.6Long Data and Auto Object Ids, ROWVERSION
19.5.7Long Data and By-Value Accessors/Modifiers



19.6SQL Server Index Definition





PART III PROFILES



20Profiles Introduction



21Boost Profile

21.1Smart Pointers Library
21.2Unordered Containers Library
21.3Multi-Index Container Library
21.4Optional Library

21.5Date Time Library

21.5.1MySQL Database Type Mapping
21.5.2SQLite Database Type Mapping
21.5.3PostgreSQL Database Type Mapping
21.5.4Oracle Database Type Mapping
21.5.5SQL Server Database Type Mapping




21.6Uuid Library

21.6.1MySQL Database Type Mapping
21.6.2SQLite Database Type Mapping
21.6.3PostgreSQL Database Type Mapping
21.6.4Oracle Database Type Mapping
21.6.5SQL Server Database Type Mapping








22Qt Profile


22.1Basic Types Library

22.1.1MySQL Database Type Mapping
22.1.2SQLite Database Type Mapping
22.1.3PostgreSQL Database Type Mapping
22.1.4Oracle Database Type Mapping
22.1.5SQL Server Database Type Mapping



22.2Smart Pointers Library

22.3Containers Library

22.3.1Change-Tracking QList




22.4Date Time Library

22.4.1MySQL Database Type Mapping
22.4.2SQLite Database Type Mapping
22.4.3PostgreSQL Database Type Mapping
22.4.4Oracle Database Type Mapping
22.4.5SQL Server Database Type Mapping











Preface

As more critical aspects of our lives become dependant on software
systems, more and more applications are required to save the data
they work on in persistent and reliable storage. Database management
systems and, in particular, relational database management systems
(RDBMS) are commonly used for such storage. However, while the
application development techniques and programming languages have
evolved significantly over the past decades, the relational database
technology in this area stayed relatively unchanged. In particular,
this led to the now infamous mismatch between the object-oriented
model used by many modern applications and the relational model still
used by RDBMS.

While relational databases may be inconvenient to use from modern
programming languages, they are still the main choice for many
applications due to their maturity, reliability, as well as the
availability of tools and alternative implementations.

To allow application developers to utilize relational databases
from their object-oriented applications, a technique called
object-relational mapping (ORM) is often used. It involves a
conversion layer that maps between objects in the application's
memory and their relational representation in the database. While
the object-relational mapping code can be written manually,
automated ORM systems are available for most object-oriented
programming languages in use today.

ODB is an ORM system for the C++ programming language. It was
designed and implemented with the following main goals:


Provide a fully-automatic ORM system. In particular, the
application developer should not have to manually write any
mapping code, neither for persistent classes nor for their
data member.

Provide clean and easy to use object-oriented persistence
model and database APIs that support the development of realistic
applications for a wide variety of domains.

Provide a portable and thread-safe implementation. ODB should be
written in standard C++ and capable of persisting any standard
C++ classes.

Provide profiles that integrate ODB with type systems of
widely-used frameworks and libraries such as Qt and Boost.

Provide a high-performance and low overhead implementation. ODB
should make efficient use of database and application resources.




About This Document

The goal of this manual is to provide you with an understanding
of the object persistence model and APIs which are implemented by ODB.
As such, this document is intended for C++ application developers and
software architects who are looking for a C++ object persistence
solution. Prior experience with C++ is required to understand
this document. A basic understanding of relational database systems
is advantageous but not expected or required.


More Information

Beyond this manual, you may also find the following sources of
information useful:


ODB
Compiler Command Line Manual.

The INSTALL files in the ODB source packages provide
build instructions for various platforms.

The odb-examples package contains a collection of
examples and a README file with an overview of each example.

The odb-users
mailing list is the place to ask technical questions about ODB.
Furthermore, the searchable
archives
may already have answers to some of your questions.








PART I
OBJECT-RELATIONAL MAPPING

Part I describes the essential database concepts, APIs, and tools that
together comprise the object-relational mapping for C++ as implemented
by ODB. It consists of the following chapters.


1Introduction
2Hello World Example
3Working with Persistent Objects
4Querying the Database
5Containers
6Relationships
7Value Types
8Inheritance
9Views
10Session
11Optimistic Concurrency
12ODB Pragma Language







1 Introduction

ODB is an object-relational mapping (ORM) system for C++. It provides
tools, APIs, and library support that allow you to persist C++ objects
to a relational database (RDBMS) without having to deal with tables,
columns, or SQL and without manually writing any of the mapping code.

ODB is highly flexible and customizable. It can either completely
hide the relational nature of the underlying database or expose
some of the details as required. For example, you can automatically
map basic C++ types to suitable SQL types, generate the relational
database schema for your persistent classes, and use simple, safe,
and yet powerful object query language instead of SQL. Or you can
assign SQL types to individual data members, use the existing
database schema, and run native SQL SELECT queries.
In fact, at an extreme, ODB can be used as just a convenient
way to handle results of native SQL queries.

ODB is not a framework. It does not dictate how you should write
your application. Rather, it is designed to fit into your
style and architecture by only handling object persistence
and not interfering with any other functionality. There is
no common base type that all persistent classes should derive
from nor are there any restrictions on the data member types
in persistent classes. Existing classes can be made persistent
with a few or no modifications.

ODB has been designed for high performance and low memory
overhead. Prepared statements are used to send and receive
object state in binary format instead of text which reduces
the load on the application and the database server. Extensive
caching of connections, prepared statements, and buffers saves
time and resources on connection establishment, statement parsing,
and memory allocations. For each supported database system the
native C API is used instead of ODBC or higher-level wrapper
APIs to reduce overhead and provide the most efficient implementation
for each database operation. Finally, persistent classes have
zero memory overhead. There are no hidden "database" members
that each class must have nor are there per-object data structures
allocated by ODB.

In this chapter we present a high-level overview of ODB.
We will start with the ODB architecture and then outline the
workflow of building an application that uses ODB. We will
then continue by contrasting the drawbacks of the traditional
way of saving C++ objects to relational databases with the
benefits of using ODB for object persistence. We conclude the
chapter by discussing the C++ standards supported by ODB. The
next chapter takes a more hands-on approach and shows the
concrete steps necessary to implement object persistence in
a simple "Hello World" application.

1.1 Architecture and Workflow

From the application developer's perspective, ODB
consists of three main components: the ODB compiler, the common
runtime library, called libodb, and the
database-specific runtime libraries, called
libodb-<database>, where <database> is
the name of the database system this runtime
is for, for example, libodb-mysql. For instance,
if the application is going to use the MySQL database for
object persistence, then the three ODB components that this
application will use are the ODB compiler, libodb
and libodb-mysql.

The ODB compiler generates the database support code for
persistent classes in your application. The input to the ODB
compiler is one or more C++ header files defining C++ classes
that you want to make persistent. For each input header file
the ODB compiler generates a set of C++ source files implementing
conversion between persistent C++ classes defined in this
header and their database representation. The ODB compiler
can also generate a database schema file that creates tables
necessary to store the persistent classes.

The ODB compiler is a real C++ compiler except that it produces
C++ instead of assembly or machine code. In particular, it is not
an ad-hoc header pre-processor that is only capable of recognizing
a subset of C++. ODB is capable of parsing any standard C++ code.

The common runtime library defines database system-independent
interfaces that your application can use to manipulate persistent
objects. The database-specific runtime library provides implementations
of these interfaces for a concrete database as well as other
database-specific utilities that are used by the generated code.
Normally, the application does not use the database-specific
runtime library directly but rather works with it via the common
interfaces from libodb. The following diagram shows
the object persistence architecture of an application that uses
MySQL as the underlying database system:




The ODB system also defines two special-purpose languages:
the ODB Pragma Language and ODB Query Language. The ODB Pragma
Language is used to communicate various properties of persistent
classes to the ODB compiler by means of special #pragma
directives embedded in the C++ header files. It controls aspects
of the object-relational mapping such as names of tables and columns
that are used for persistent classes and their members or mapping between
C++ types and database types.

The ODB Query Language is an object-oriented database query
language that can be used to search for objects matching
certain criteria. It is modeled after and is integrated into
C++ allowing you to write expressive and safe queries that look
and feel like ordinary C++.

The use of the ODB compiler to generate database support code
adds an additional step to your application build sequence. The
following diagram outlines the typical build workflow of an
application that uses ODB:




1.2 Benefits

The traditional way of saving C++ objects to relational databases
requires that you manually write code which converts between the database
and C++ representations of each persistent class. The actions that
such code usually performs include conversion between C++ values and
strings or database types, preparation and execution of SQL queries,
as well as handling the result sets. Writing this code manually has
the following drawbacks:


Difficult and time consuming. Writing database conversion
code for any non-trivial application requires extensive
knowledge of the specific database system and its APIs.
It can also take a considerable amount of time to write
and maintain. Supporting multi-threaded applications can
complicate this task even further.

Suboptimal performance. Optimal conversion often
requires writing large amounts of extra code, such as
parameter binding for prepared statements and caching
of connections, statements, and buffers. Writing code
like this in an ad-hoc manner is often too difficult
and time consuming.

Database vendor lock-in. The conversion code is written for
a specific database which makes it hard to switch to another
database vendor.

Lack of type safety. It is easy to misspell column names or
pass incompatible values in SQL queries. Such errors will
only be detected at runtime.

Complicates the application. The database conversion code
often ends up interspersed throughout the application making it
hard to debug, change, and maintain.


In contrast, using ODB for C++ object persistence has the
following benefits:


Ease of use. ODB automatically generates database conversion
code from your C++ class declarations and allows you to manipulate
persistent objects using simple and thread-safe object-oriented
database APIs.

Concise code. With ODB hiding the details of the underlying
database, the application logic is written using the natural object
vocabulary instead of tables, columns and SQL. The resulting code
is simpler and thus easier to read and understand.

Optimal performance. ODB has been designed for high performance
and low memory overhead. All the available optimization techniques,
such as prepared statements and extensive connection, statement,
and buffer caching, are used to provide the most efficient
implementation for each database operation.

Database portability. Because the database conversion code
is automatically generated, it is easy to switch from one database
vendor to another. In fact, it is possible to test your application
on several database systems before making a choice.

Safety. The ODB object persistence and query APIs are
statically typed. You use C++ identifiers instead of strings
to refer to object members and the generated code makes sure
database and C++ types are compatible. All this helps catch
programming errors at compile-time rather than at runtime.

Maintainability. Automatic code generation minimizes the
effort needed to adapt the application to changes in persistent
classes. The database support code is kept separately from the
class declarations and application logic. This makes the
application easier to debug and maintain.


Overall, ODB provides an easy to use yet flexible and powerful
object-relational mapping (ORM) system for C++. Unlike other
ORM implementations for C++ that still require you to write
database conversion or member registration code for each
persistent class, ODB keeps persistent classes purely
declarative. The functional part, the database conversion
code, is automatically generated by the ODB compiler from
these declarations.

1.3 Supported C++ Standards

ODB provides support for ISO/IEC C++ 1998/2003 (C++98/03),
ISO/IEC TR 19768 C++ Library Extensions (C++ TR1), and
ISO/IEC C++ 2011 (C++11). While the majority of the examples in
this manual use C++98/03, support for the new functionality and
library components introduced in TR1 and C++11 are discussed
throughout the document. The c++11 example in the
odb-examples package also shows ODB support for
various C++11 features.





2 Hello World Example

In this chapter we will show how to create a simple C++
application that relies on ODB for object persistence using
the traditional "Hello World" example. In particular, we will
discuss how to declare persistent classes, generate database
support code, as well as compile and run our application. We
will also learn how to make objects persistent, load, update
and delete persistent objects, as well as query the database
for persistent objects that match certain criteria. The example
also shows how to define and use views, a mechanism that allows
us to create projections of persistent objects, database tables,
or to handle results of native SQL queries.

The code presented in this chapter is based on the
hello example which can be found in the
odb-examples package of the ODB distribution.

2.1 Declaring a Persistent Class

In our "Hello World" example we will depart slightly from
the norm and say hello to people instead of the world. People
in our application will be represented as objects of C++ class
person which is saved in person.hxx:


// person.hxx
//

#include <string>

class person
{
public:
person (const std::string& first,
const std::string& last,
unsigned short age);

const std::string& first () const;
const std::string& last () const;

unsigned short age () const;
void age (unsigned short);

private:
std::string first_;
std::string last_;
unsigned short age_;
};


In order not to miss anyone whom we need to greet, we would like
to save the person objects in a database. To achieve this
we declare the person class as persistent:


// person.hxx
//

#include <string>

#include <odb/core.hxx> // (1)

#pragma db object // (2)
class person
{
...

private:
person () {} // (3)

friend class odb::access; // (4)

#pragma db id auto // (5)
unsigned long id_; // (5)

std::string first_;
std::string last_;
unsigned short age_;
};


To be able to save the person objects in the database
we had to make five changes, marked with (1) to (5), to the original
class definition. The first change is the inclusion of the ODB
header <odb/core.hxx>. This header provides a number
of core ODB declarations, such as odb::access, that
are used to define persistent classes.

The second change is the addition of db object
pragma just before the class definition. This pragma tells the
ODB compiler that the class that follows is persistent. Note
that making a class persistent does not mean that all objects
of this class will automatically be stored in the database.
You would still create ordinary or transient instances
of this class just as you would before. The difference is that
now you can make such transient instances persistent, as we will
see shortly.

The third change is the addition of the default constructor.
The ODB-generated database support code will use this constructor
when instantiating an object from the persistent state. Just as we have
done for the person class, you can make the default
constructor private or protected if you don't want to make it
available to the users of your class. Note also that with some
limitations it is possible to have a persistent class without
the default constructor.

With the fourth change we make the odb::access class a
friend of our person class. This is necessary to make
the default constructor and the data members accessible to the
database support code. If your class has a public default constructor and
either public data members or public accessors and modifiers for the
data members, then the friend declaration is unnecessary.

The final change adds a data member called id_ which
is preceded by another pragma. In ODB every persistent object normally
has a unique, within its class, identifier. Or, in other words, no two
persistent instances of the same type have equal identifiers. While it
is possible to define a persistent class without an object id, the number
of database operations that can be performed on such a class is limited.
For our class we use an integer id. The db id auto
pragma that precedes the id_ member tells the ODB compiler
that the following member is the object's identifier. The
auto specifier indicates that it is a database-assigned
id. A unique id will be automatically generated by the database and
assigned to the object when it is made persistent.

In this example we chose to add an identifier because none of
the existing members could serve the same purpose. However, if
a class already has a member with suitable properties, then it
is natural to use that member as an identifier. For example,
if our person class contained some form of personal
identification (SSN in the United States or ID/passport number
in other countries), then we could use that as an id. Or, if
we stored an email associated with each person, then we could
have used that if each person is presumed to have a unique
email address.

As another example, consider the following alternative version
of the person class. Here we use one of
the existing data members as id. Also the data members are kept
private and are instead accessed via public accessor and modifier
functions. Finally, the ODB pragmas are grouped together and are
placed after the class definition. They could have also been moved
into a separate header leaving the original class completely
unchanged (for more information on such a non-intrusive conversion
refer to Chapter 12, "ODB Pragma Language").


class person
{
public:
person ();

const std::string& email () const;
void email (const std::string&);

const std::string& get_name () const;
std::string& set_name ();

unsigned short getAge () const;
void setAge (unsigned short);

private:
std::string email_;
std::string name_;
unsigned short age_;
};

#pragma db object(person)
#pragma db member(person::email_) id


Now that we have the header file with the persistent class, let's
see how we can generate that database support code.

2.2 Generating Database Support Code

The persistent class definition that we created in the previous
section was particularly light on any code that could actually
do the job and store the person's data to a database. There
was no serialization or deserialization code, not even data member
registration, that you would normally have to write by hand in
other ORM libraries for C++. This is because in ODB code
that translates between the database and C++ representations
of an object is automatically generated by the ODB compiler.

To compile the person.hxx header we created in the
previous section and generate the support code for the MySQL
database, we invoke the ODB compiler from a terminal (UNIX) or
a command prompt (Windows):


odb -d mysql --generate-query person.hxx


We will use MySQL as the database of choice in the remainder of
this chapter, though other supported database systems can be used
instead.

If you haven't installed the common ODB runtime library
(libodb) or installed it into a directory where
C++ compilers don't search for headers by default,
then you may get the following error:


person.hxx:10:24: fatal error: odb/core.hxx: No such file or directory


To resolve this you will need to specify the libodb headers
location with the -I preprocessor option, for example:


odb -I.../libodb -d mysql --generate-query person.hxx


Here .../libodb represents the path to the
libodb directory.

The above invocation of the ODB compiler produces three C++ files:
person-odb.hxx, person-odb.ixx,
person-odb.cxx. You normally don't use types
or functions contained in these files directly. Rather, all
you have to do is include person-odb.hxx in
C++ files where you are performing database operations
with classes from person.hxx as well as compile
person-odb.cxx and link the resulting object
file to your application.

You may be wondering what the --generate-query
option is for. It instructs the ODB compiler to generate
optional query support code that we will use later in our
"Hello World" example. Another option that we will find
useful is --generate-schema. This option
makes the ODB compiler generate a fourth file,
person.sql, which is the database schema
for the persistent classes defined in person.hxx:


odb -d mysql --generate-query --generate-schema person.hxx


The database schema file contains SQL statements that creates
tables necessary to store the persistent classes. We will learn
how to use it in the next section.

If you would like to see a list of all the available ODB compiler
options, refer to the
ODB
Compiler Command Line Manual.

Now that we have the persistent class and the database support
code, the only part that is left is the application code that
does something useful with all of this. But before we move on to
the fun part, let's first learn how to build and run an application
that uses ODB. This way when we have some application code
to try, there are no more delays before we can run it.

2.3 Compiling and Running

Assuming that the main() function with the application
code is saved in driver.cxx and the database support
code and schema are generated as described in the previous section,
to build our application we will first need to compile all the C++
source files and then link them with two ODB runtime libraries.

On UNIX, the compilation part can be done with the following commands
(substitute c++ with your C++ compiler name; for Microsoft
Visual Studio setup, see the odb-examples package):


c++ -c driver.cxx
c++ -c person-odb.cxx


Similar to the ODB compilation, if you get an error stating that
a header in odb/ or odb/mysql directory
is not found, you will need to use the -I
preprocessor option to specify the location of the common ODB runtime
library (libodb) and MySQL ODB runtime library
(libodb-mysql).

Once the compilation is done, we can link the application with
the following command:


c++ -o driver driver.o person-odb.o -lodb-mysql -lodb


Notice that we link our application with two ODB libraries:
libodb which is a common runtime library and
libodb-mysql which is a MySQL runtime library
(if you use another database, then the name of this library
will change accordingly). If you get an error saying that
one of these libraries could not be found, then you will need
to use the -L linker option to specify their locations.

Before we can run our application we need to create a database
schema using the generated person.sql file. For MySQL
we can use the mysql client program, for example:


mysql --user=odb_test --database=odb_test < person.sql


The above command will log in to a local MySQL server as user
odb_test without a password and use the database
named odb_test. Beware that after executing this
command, all the data stored in the odb_test database
will be deleted.

Note also that using a standalone generated SQL file is not the
only way to create a database schema in ODB. We can also embed
the schema directly into our application or use custom schemas
that were not generated by the ODB compiler. Refer to
Section 3.4, "Database" for details.

Once the database schema is ready, we run our application
using the same login and database name:


./driver --user odb_test --database odb_test



2.4 Making Objects Persistent

Now that we have the infrastructure work out of the way, it
is time to see our first code fragment that interacts with the
database. In this section we will learn how to make person
objects persistent:


// driver.cxx
//

#include <memory> // std::auto_ptr
#include <iostream>

#include <odb/database.hxx>
#include <odb/transaction.hxx>

#include <odb/mysql/database.hxx>

#include "person.hxx"
#include "person-odb.hxx"

using namespace std;
using namespace odb::core;

int
main (int argc, char* argv[])
{
try
{
auto_ptr<database> db (new odb::mysql::database (argc, argv));

unsigned long john_id, jane_id, joe_id;

// Create a few persistent person objects.
//
{
person john ("John", "Doe", 33);
person jane ("Jane", "Doe", 32);
person joe ("Joe", "Dirt", 30);

transaction t (db->begin ());

// Make objects persistent and save their ids for later use.
//
john_id = db->persist (john);
jane_id = db->persist (jane);
joe_id = db->persist (joe);

t.commit ();
}
}
catch (const odb::exception& e)
{
cerr << e.what () << endl;
return 1;
}
}


Let's examine this code piece by piece. At the beginning we include
a bunch of headers. After the standard C++ headers we include
<odb/database.hxx>
and <odb/transaction.hxx> which define database
system-independent odb::database and
odb::transaction interfaces. Then we include
<odb/mysql/database.hxx> which defines the
MySQL implementation of the database interface. Finally,
we include person.hxx and person-odb.hxx
which define our persistent person class.

Then we have two using namespace directives. The first
one brings in the names from the standard namespace and the second
brings in the ODB declarations which we will use later in the file.
Notice that in the second directive we use the odb::core
namespace instead of just odb. The former only brings
into the current namespace the essential ODB names, such as the
database and transaction classes, without
any of the auxiliary objects. This minimizes the likelihood of name
conflicts with other libraries. Note also that you should continue
using the odb namespace when qualifying individual names.
For example, you should write odb::database, not
odb::core::database.

Once we are in main(), the first thing we do is create
the MySQL database object. Notice that this is the last line in
driver.cxx that mentions MySQL explicitly; the rest
of the code works through the common interfaces and is database
system-independent. We use the argc/argv
mysql::database constructor which automatically
extract the database parameters, such as login name, password,
database name, etc., from the command line. In your own applications
you may prefer to use other mysql::database
constructors which allow you to pass this information directly
(Section 15.2, "MySQL Database Class").

Next, we create three person objects. Right now they are
transient objects, which means that if we terminate the application
at this point, they will be gone without any evidence of them ever
existing. The next line starts a database transaction. We discuss
transactions in detail later in this manual. For now, all we need
to know is that all ODB database operations must be performed within
a transaction and that a transaction is an atomic unit of work; all
database operations performed within a transaction either succeed
(committed) together or are automatically undone (rolled back).

Once we are in a transaction, we call the persist()
database function on each of our person objects.
At this point the state of each object is saved in the database.
However, note that this state is not permanent until and unless
the transaction is committed. If, for example, our application
crashes at this point, there will still be no evidence of our
objects ever existing.

In our case, one more thing happens when we call persist().
Remember that we decided to use database-assigned identifiers for our
person objects. The call to persist() is
where this assignment happens. Once this function returns, the
id_ member contains this object's unique identifier.
As a convenience, the persist() function also returns
a copy of the object's identifier that it made persistent. We
save the returned identifier for each object in a local variable.
We will use these identifiers later in the chapter to perform other
database operations on our persistent objects.

After we have persisted our objects, it is time to commit the
transaction and make the changes permanent. Only after the
commit() function returns successfully, are we
guaranteed that the objects are made persistent. Continuing
with the crash example, if our application terminates after
the commit for whatever reason, the objects' state in the
database will remain intact. In fact, as we will discover
shortly, our application can be restarted and load the
original objects from the database. Note also that a
transaction must be committed explicitly with the
commit() call. If the transaction
object leaves scope without the transaction being
explicitly committed or rolled back, it will automatically be
rolled back. This behavior allows you not to worry about
exceptions being thrown within a transaction; if they
cross the transaction boundary, the transaction will
automatically be rolled back and all the changes made
to the database undone.

The final bit of code in our example is the catch
block that handles the database exceptions. We do this by catching
the base ODB exception (Section 3.14, "ODB
Exceptions") and printing the diagnostics.

Let's now compile (Section 2.3, "Compiling and
Running") and then run our first ODB application:


mysql --user=odb_test --database=odb_test < person.sql
./driver --user odb_test --database odb_test


Our first application doesn't print anything except for error
messages so we can't really tell whether it actually stored the
objects' state in the database. While we will make our application
more entertaining shortly, for now we can use the mysql
client to examine the database content. It will also give us a feel
for how the objects are stored:


mysql --user=odb_test --database=odb_test

Welcome to the MySQL monitor.

mysql> select * from person;

+----+-------+------+-----+
| id | first | last | age |
+----+-------+------+-----+
| 1 | John | Doe | 33 |
| 2 | Jane | Doe | 32 |
| 3 | Joe | Dirt | 30 |
+----+-------+------+-----+
3 rows in set (0.00 sec)

mysql> quit


Another way to get more insight into what's going on under the hood,
is to trace the SQL statements executed by ODB as a result of
each database operation. Here is how we can enable tracing just for
the duration of our transaction:


// Create a few persistent person objects.
//
{
...

transaction t (db->begin ());

t.tracer (stderr_tracer);

// Make objects persistent and save their ids for later use.
//
john_id = db->persist (john);
jane_id = db->persist (jane);
joe_id = db->persist (joe);

t.commit ();
}


With this modification our application now produces the following
output:


INSERT INTO `person` (`id`,`first`,`last`,`age`) VALUES (?,?,?,?)
INSERT INTO `person` (`id`,`first`,`last`,`age`) VALUES (?,?,?,?)
INSERT INTO `person` (`id`,`first`,`last`,`age`) VALUES (?,?,?,?)


Note that we see question marks instead of the actual values
because ODB uses prepared statements and sends the data to the
database in binary form. For more information on tracing, refer
to Section 3.13, "Tracing SQL Statement Execution".
In the next section we will see how to access persistent objects
from our application.

2.5 Querying the Database for Objects

So far our application doesn't resemble a typical "Hello World"
example. It doesn't print anything except for error messages.
Let's change that and teach our application to say hello to
people from our database. To make it a bit more interesting,
let's say hello only to people over 30:


// driver.cxx
//

...

int
main (int argc, char* argv[])
{
try
{
...

// Create a few persistent person objects.
//
{
...
}

typedef odb::query<person> query;
typedef odb::result<person> result;

// Say hello to those over 30.
//
{
transaction t (db->begin ());

result r (db->query<person> (query::age > 30));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
cout << "Hello, " << i->first () << "!" << endl;
}

t.commit ();
}
}
catch (const odb::exception& e)
{
cerr << e.what () << endl;
return 1;
}
}


The first half of our application is the same as before and is
replaced with "..." in the above listing for brevity. Again, let's
examine the rest of it piece by piece.

The two typedefs create convenient aliases for two
template instantiations that will be used a lot in our application.
The first is the query type for the person objects
and the second is the result type for that query.

Then we begin a new transaction and call the query()
database function. We pass a query expression
(query::age > 30) which limits the returned objects
only to those with the age greater than 30. We also save the result
of the query in a local variable.

The next few lines perform a standard for-loop iteration
over the result sequence printing hello for every returned person.
Then we commit the transaction and that's it. Let's see what
this application will print:


mysql --user=odb_test --database=odb_test < person.sql
./driver --user odb_test --database odb_test

Hello, John!
Hello, Jane!



That looks about right, but how do we know that the query actually
used the database instead of just using some in-memory artifacts of
the earlier persist() calls? One way to test this
would be to comment out the first transaction in our application
and re-run it without re-creating the database schema. This way the
objects that were persisted during the previous run will be returned.
Alternatively, we can just re-run the same application without
re-creating the schema and notice that we now show duplicate
objects:


./driver --user odb_test --database odb_test

Hello, John!
Hello, Jane!
Hello, John!
Hello, Jane!


What happens here is that the previous run of our application
persisted a set of person objects and when we re-run
the application, we persist another set with the same names but
with different ids. When we later run the query, matches from
both sets are returned. We can change the line where we print
the "Hello" string as follows to illustrate this point:


cout << "Hello, " << i->first () << " (" << i->id () << ")!" << endl;


If we now re-run this modified program, again without re-creating
the database schema, we will get the following output:


./driver --user odb_test --database odb_test

Hello, John (1)!
Hello, Jane (2)!
Hello, John (4)!
Hello, Jane (5)!
Hello, John (7)!
Hello, Jane (8)!


The identifiers 3, 6, and 9 that are missing from the above list belong
to the "Joe Dirt" objects which are not selected by this query.

2.6 Updating Persistent Objects

While making objects persistent and then selecting some of them using
queries are two useful operations, most applications will also need
to change the object's state and then make these changes persistent.
Let's illustrate this by updating Joe's age who just had a birthday:


// driver.cxx
//

...

int
main (int argc, char* argv[])
{
try
{
...

unsigned long john_id, jane_id, joe_id;

// Create a few persistent person objects.
//
{
...

// Save object ids for later use.
//
john_id = john.id ();
jane_id = jane.id ();
joe_id = joe.id ();
}

// Joe Dirt just had a birthday, so update his age.
//
{
transaction t (db->begin ());

auto_ptr<person> joe (db->load<person> (joe_id));
joe->age (joe->age () + 1);
db->update (*joe);

t.commit ();
}

// Say hello to those over 30.
//
{
...
}
}
catch (const odb::exception& e)
{
cerr << e.what () << endl;
return 1;
}
}


The beginning and the end of the new transaction are the same as
the previous two. Once within a transaction, we call the
load() database function to instantiate a
person object with Joe's persistent state. We
pass Joe's object identifier that we stored earlier when we
made this object persistent. While here we use
std::auto_ptr to manage the returned object, we
could have also used another smart pointer, for example
std::unique_ptr from C++11 or shared_ptr
from TR1, C++11, or Boost. For more information
on the object lifetime management and the smart pointers that we
can use for that, see Section 3.3, "Object
and View Pointers".

With the instantiated object in hand we increment the age
and call the update() function to update
the object's state in the database. Once the transaction is
committed, the changes are made permanent.

If we now run this application, we will see Joe in the output
since he is now over 30:


mysql --user=odb_test --database=odb_test < person.sql
./driver --user odb_test --database odb_test

Hello, John!
Hello, Jane!
Hello, Joe!


What if we didn't have an identifier for Joe? Maybe this object
was made persistent in another run of our application or by another
application altogether. Provided that we only have one Joe Dirt
in the database, we can use the query facility to come up with
an alternative implementation of the above transaction:


// Joe Dirt just had a birthday, so update his age. An
// alternative implementation without using the object id.
//
{
transaction t (db->begin ());

result r (db->query<person> (query::first == "Joe" &&
query::last == "Dirt"));

result::iterator i (r.begin ());

if (i != r.end ())
{
auto_ptr<person> joe (i.load ());
joe->age (joe->age () + 1);
db->update (*joe);
}

t.commit ();
}


2.7 Defining and Using Views

Suppose that we need to gather some basic statistics about the people
stored in our database. Things like the total head count, as well as
the minimum and maximum ages. One way to do it would be to query
the database for all the person objects and then
calculate this information as we iterate over the query result.
While this approach may work fine for our database with just three
people in it, it would be very inefficient if we had a large
number of objects.

While it may not be conceptually pure from the object-oriented
programming point of view, a relational database can perform
some computations much faster and much more economically than
if we performed the same operations ourselves in the application's
process.

To support such cases ODB provides the notion of views. An ODB view
is a C++ class that embodies a light-weight, read-only
projection of one or more persistent objects or database tables or
the result of a native SQL query execution.

Some of the common applications of views include loading a subset of
data members from objects or columns database tables, executing and
handling results of arbitrary SQL queries, including aggregate
queries, as well as joining multiple objects and/or database
tables using object relationships or custom join conditions.

While you can find a much more detailed description of views in
Chapter 9, "Views", here is how we can define
the person_stat view that returns the basic statistics
about the person objects:


#pragma db view object(person)
struct person_stat
{
#pragma db column("count(" + person::id_ + ")")
std::size_t count;

#pragma db column("min(" + person::age_ + ")")
unsigned short min_age;

#pragma db column("max(" + person::age_ + ")")
unsigned short max_age;
};


To get the result of a view we use the same query()
function as when querying the database for an object. Here is
how we can load and print our statistics using the view we have
just created:


// Print some statistics about all the people in our database.
//
{
transaction t (db->begin ());

odb::result<person_stat> r (db->query<person_stat> ());

// The result of this query always has exactly one element.
//
const person_stat& ps (*r.begin ());

cout << "count : " << ps.count << endl
<< "min age: " << ps.min_age << endl
<< "max age: " << ps.max_age << endl;

t.commit ();
}


If we now add the person_stat view to the
person.hxx header, the above transaction
to driver.cxx, as well as re-compile and
re-run our example, then we will see the following
additional lines in the output:


count : 3
min age: 31
max age: 33


2.8 Deleting Persistent Objects

The last operation that we will discuss in this chapter is deleting
the persistent object from the database. The following code
fragment shows how we can delete an object given its identifier:


// John Doe is no longer in our database.
//
{
transaction t (db->begin ());
db->erase<person> (john_id);
t.commit ();
}


To delete John from the database we start a transaction, call
the erase() database function with John's object
id, and commit the transaction. After the transaction is committed,
the erased object is no longer persistent.

If we don't have an object id handy, we can use queries to find
and delete the object:


// John Doe is no longer in our database. An alternative
// implementation without using the object id.
//
{
transaction t (db->begin ());

result r (db->query<person> (query::first == "John" &&
query::last == "Doe"));

result::iterator i (r.begin ());

if (i != r.end ())
{
auto_ptr<person> john (i.load ());
db->erase (*john);
}

t.commit ();
}


2.9 Working with Multiple Databases

Accessing multiple databases (that is, data stores) is simply a
matter of creating multiple odb::<db>::database
instances representing each database. For example:


odb::mysql::database db1 ("john", "secret", "test_db1");
odb::mysql::database db2 ("john", "secret", "test_db2");


A more interesting question is how we access multiple database
systems (that is, database implementations) from the same application.
For example, our application may need to store some objects in a
remote MySQL database and others in a local SQLite file. Or, our
application may need to be able to store its objects in a database
system that is selected by the user at runtime.

ODB provides comprehensive multi-database support that ranges from
tight integration with specific database systems to being able to
write database-agnostic code and loading individual database systems
support dynamically. While all these aspects are covered in detail
in Chapter 14, "Multi-Database Support", in this
section we will get a taste of this functionality by extending our
"Hello World" example to be able to store its data either in MySQL
or PostgreSQL (other database systems supported by ODB can be added
in a similar manner).

The first step in adding multi-database support is to re-compile
our person.hxx header to generate database support
code for additional database systems:


odb --multi-database dynamic -d common -d mysql -d pgsql \
--generate-query --generate-schema person.hxx


The --multi-database ODB compiler option turns on
multi-database support. For now it is not important what the
dynamic value that we passed to this option means, but
if you are curious, see Chapter 14. The result of this
command are three sets of generated files: person-odb.?xx
(common interface; corresponds to the common database),
person-odb-mysql.?xx (MySQL support code), and
person-odb-pgsql.?xx (PostgreSQL support code). There
are also two schema files: person-mysql.sql and
person-pgsql.sql.

The only part that we need to change in driver.cxx
is how we create the database instance. Specifically, this line:


auto_ptr<database> db (new odb::mysql::database (argc, argv));


Now our example is capable of storing its data either in MySQL or
PostgreSQL so we need to somehow allow the caller to specify which
database we must use. To keep things simple, we will make the first
command line argument specify the database system we must use while
the rest will contain the database-specific options which we will
pass to the odb::<db>::database constructor as
before. Let's put all this logic into a separate function which we
will call create_database(). Here is what the beginning
of our modified driver.cxx will look like (the remainder
is unchanged):


// driver.cxx
//

#include <string>
#include <memory> // std::auto_ptr
#include <iostream>

#include <odb/database.hxx>
#include <odb/transaction.hxx>

#include <odb/mysql/database.hxx>
#include <odb/pgsql/database.hxx>

#include "person.hxx"
#include "person-odb.hxx"

using namespace std;
using namespace odb::core;

auto_ptr<database>
create_database (int argc, char* argv[])
{
auto_ptr<database> r;

if (argc < 2)
{
cerr << "error: database system name expected" << endl;
return r;
}

string db (argv[1]);

if (db == "mysql")
r.reset (new odb::mysql::database (argc, argv));
else if (db == "pgsql")
r.reset (new odb::pgsql::database (argc, argv));
else
cerr << "error: unknown database system " << db << endl;

return r;
}

int
main (int argc, char* argv[])
{
try
{
auto_ptr<database> db (create_database (argc, argv));

if (db.get () == 0)
return 1; // Diagnostics has already been issued.

...


And that's it. The only thing left is to build and run our
example:


c++ -c driver.cxx
c++ -c person-odb.cxx
c++ -c person-odb-mysql.cxx
c++ -c person-odb-pgsql.cxx
c++ -o driver driver.o person-odb.o person-odb-mysql.o \
person-odb-pgsql.o -lodb-mysql -lodb-pgsql -lodb


Here is how we can access a MySQL database:


mysql --user=odb_test --database=odb_test < person-mysql.sql
./driver mysql --user odb_test --database odb_test


Or a PostgreSQL database:


psql --user=odb_test --dbname=odb_test -f person-pgsql.sql
./driver pgsql --user odb_test --database odb_test


2.10 Summary

This chapter presented a very simple application which, nevertheless,
exercised all of the core database functions: persist(),
query(), load(), update(),
and erase(). We also saw that writing an application
that uses ODB involves the following steps:


Declare persistent classes in header files.
Compile these headers to generate database support code.
Link the application with the generated code and two ODB runtime
libraries.




Do not be concerned if, at this point, much appears unclear. The intent
of this chapter is to give you only a general idea of how to persist C++
objects with ODB. We will cover all the details throughout the remainder
of this manual.






3 Working with Persistent Objects

The previous chapters gave us a high-level overview of ODB and
showed how to use it to store C++ objects in a database. In this
chapter we will examine the ODB object persistence model as
well as the core database APIs in greater detail. We will
start with basic concepts and terminology in Section
3.1 and Section 3.3 and continue with the
discussion of the odb::database class in
Section 3.4, transactions in
Section 3.5, and connections in
Section 3.6. The remainder of this chapter
deals with the core database operations and concludes with
the discussion of ODB exceptions.

In this chapter we will continue to use and expand the
person persistent class that we have developed in the
previous chapter.

3.1 Concepts and Terminology

The term database can refer to three distinct things:
a general notion of a place where an application stores its data,
a software implementation for managing this data (for example
MySQL), and, finally, some database software implementations
may manage several data stores which are usually distinguished
by name. This name is also commonly referred to as a database.

In this manual, when we use the word database, we
refer to the first meaning above, for example,
"The update() function saves the object's state to
the database." The term Database Management System (DBMS) is
often used to refer to the second meaning of the word database.
In this manual we will use the term database system
for short, for example, "Database system-independent
application code." Finally, to distinguish the third meaning
from the other two, we will use the term database name,
for example, "The second option specifies the database name
that the application should use to store its data."

In C++ there is only one notion of a type and an instance
of a type. For example, a fundamental type, such as int,
is, for the most part, treated the same as a user defined class
type. However, when it comes to persistence, we have to place
certain restrictions and requirements on certain C++ types that
can be stored in the database. As a result, we divide persistent
C++ types into two groups: object types and value
types. An instance of an object type is called an object
and an instance of a value type — a value.

An object is an independent entity. It can be stored, updated,
and deleted in the database independent of other objects.
Normally, an object has an identifier, called object id,
that is unique among all instances of an object type within a
database. In contrast, a value can only be stored in the database
as part of an object and doesn't have its own unique identifier.

An object consists of data members which are either values
(Chapter 7, "Value Types"), pointers
to other objects (Chapter 6, "Relationships"), or
containers of values or pointers to other objects (Chapter
5, "Containers"). Pointers to other objects and containers can
be viewed as special kinds of values since they also can only
be stored in the database as part of an object.

An object type is a C++ class. Because of this one-to-one
relationship, we will use terms object type
and object class interchangeably. In contrast,
a value type can be a fundamental C++ type, such as
int or a class type, such as std::string.
If a value consists of other values, then it is called a
composite value and its type — a
composite value type (Section 7.2,
"Composite Value Types"). Otherwise, the value is
called simple value and its type — a
simple value type (Section 7.1,
"Simple Value Types"). Note that the distinction between
simple and composite values is conceptual rather than
representational. For example, std::string
is a simple value type because conceptually string is a
single value even though the representation of the string
class may contain several data members each of which could be
considered a value. In fact, the same value type can be
viewed (and mapped) as both simple and composite by different
applications.

While not strictly necessary in a purely object-oriented application,
practical considerations often require us to only load a
subset of an object's data members or a combination of members
from several objects. We may also need to factor out some
computations to the relational database instead of performing
them in the application's process. To support such requirements
ODB distinguishes a third kind of C++ types, called views
(Chapter 9, "Views"). An ODB view is a C++
class that embodies a light-weight, read-only
projection of one or more persistent objects or database
tables or the result of a native SQL query execution.

Understanding how all these concepts map to the relational model
will hopefully make these distinctions clearer. In a relational
database an object type is mapped to a table and a value type is
mapped to one or more columns. A simple value type is mapped
to a single column while a composite value type is mapped to
several columns. An object is stored as a row in this
table and a value is stored as one or more cells in this row.
A simple value is stored in a single cell while a composite
value occupies several cells. A view is not a persistent
entity and it is not stored in the database. Rather, it is a
data structure that is used to capture a single row of an SQL
query result.

Going back to the distinction between simple and composite
values, consider a date type which has three integer
members: year, month, and day. In one application it can be
considered a composite value and each member will get its
own column in a relational database. In another application
it can be considered a simple value and stored in a single
column as a number of days from some predefined date.

Until now, we have been using the term persistent class
to refer to object classes. We will continue to do so even though
a value type can also be a class. The reason for this asymmetry
is the subordinate nature of value types when it comes to
database operations. Remember that values are never stored
directly but rather as part of an object that contains them.
As a result, when we say that we want to make a C++ class
persistent or persist an instance of a class in the database,
we invariably refer to an object class rather than a value
class.

Normally, you would use object types to model real-world entities,
things that have their own identity. For example, in the
previous chapter we created a person class to model
a person, which is a real-world entity. Name and age, which we
used as data members in our person class are clearly
values. It is hard to think of age 31 or name "Joe" as having their
own identities.

A good test to determine whether something is an object or
a value, is to consider if other objects might reference
it. A person is clearly an object because it can be referred
to by other objects such as a spouse, an employer, or a
bank. On the other hand, a person's age or name is not
something that other objects would normally refer to.

Also, when an object represents a real entity, it is easy to
choose a suitable object id. For example, for a
person there is an established notion of an identifier
(SSN, student id, passport number, etc). Another alternative
is to use a person's email address as an identifier.

Note, however, that these are only guidelines. There could
be good reasons to make something that would normally be
a value an object. Consider, for example, a database that
stores a vast number of people. Many of the person
objects in this database have the same names and surnames and
the overhead of storing them in every object may negatively
affect the performance. In this case, we could make the first name
and last name each an object and only store pointers to
these objects in the person class.

An instance of a persistent class can be in one of two states:
transient and persistent. A transient
instance only has a representation in the application's
memory and will cease to exist when the application terminates,
unless it is explicitly made persistent. In other words, a
transient instance of a persistent class behaves just like an
instance of any ordinary C++ class. A persistent instance
has a representation in both the application's memory and the
database. A persistent instance will remain even after the
application terminates unless and until it is explicitly
deleted from the database.

3.2 Declaring Persistent Objects and Values

To make a C++ class a persistent object class we declare
it as such using the db object pragma, for
example:


#pragma db object
class person
{
...
};


The other pragma that we often use is db id
which designates one of the data members as an object id, for
example:


#pragma db object
class person
{
...

#pragma db id
unsigned long id_;
};


The object id can be of a simple or composite (Section
7.2.1, "Composite Object Ids") value type. This type should be
default-constructible. It is also possible to declare a persistent
class without an object id, however, such a class will have limited
functionality (Section 12.1.6,
"no_id").

The above two pragmas are the minimum required to declare a
persistent class with an object id. Other pragmas can be used to
fine-tune the database-related properties of a class and its
members (Chapter 12, "ODB Pragma Language").

Normally, a persistent class should define the default constructor. The
generated database support code uses this constructor when
instantiating an object from the persistent state. If we add the
default constructor only for the database support code, then we
can make it private provided we also make the odb::access
class, defined in the <odb/core.hxx> header, a
friend of this object class. For example:


#include <odb/core.hxx>

#pragma db object
class person
{
...

private:
friend class odb::access;
person () {}
};


It is also possible to have an object class without the default
constructor. However, in this case, the database operations will
only be able to load the persistent state into an existing instance
(Section 3.9, "Loading Persistent Objects",
Section 4.4, "Query Result").

The ODB compiler also needs access to the non-transient
(Section 12.4.11, "transient")
data members of a persistent class. The ODB compiler can access
such data members directly if they are public. It can also do
so if they are private or protected and the odb::access
class is declared a friend of the object type. For example:


#include <odb/core.hxx>

#pragma db object
class person
{
...

private:
friend class odb::access;
person () {}

#pragma db id
unsigned long id_;

std::string name_;
};


If data members are not accessible directly, then the ODB
compiler will try to automatically find suitable accessor and
modifier functions. To accomplish this, the ODB compiler will
try to lookup common accessor and modifier names derived from
the data member name. Specifically, for the name_
data member in the above example, the ODB compiler will look
for accessor functions with names: get_name(),
getName(), getname(), and just
name() as well as for modifier functions with
names: set_name(), setName(),
setname(), and just name(). You can
also add support for custom name derivations with the
--accessor-regex and --modifier-regex
ODB compiler options. Refer to the
ODB
Compiler Command Line Manual for details on these options.
The following example illustrates automatic accessor and modifier
discovery:


#pragma db object
class person
{
public:
person () {}

...

unsigned long id () const;
void id (unsigned long);

const std::string& get_name () const;
std::string& set_name ();

private:
#pragma db id
unsigned long id_; // Uses id() for access.

std::string name_; // Uses get_name()/set_name() for access.
};


Finally, if a data member is not directly accessible and the
ODB compiler was unable to discover suitable accessor and
modifier functions, then we can provide custom accessor
and modifier expressions using the db get
and db set pragmas. For more information
on custom accessor and modifier expressions refer to
Section 12.4.5,
"get/set/access".

You may be wondering whether we also have to declare value types
as persistent. We don't need to do anything special for simple value
types such as int or std::string since the
ODB compiler knows how to map them to suitable database types and
how to convert between the two. On the other hand, if a simple value
is unknown to the ODB compiler then we will need to provide the
mapping to the database type and, possibly, the code to
convert between the two. For more information on how to achieve
this refer to the db type pragma description
in Section 12.3.1, "type".

Similar to object classes, composite value types have to be
explicitly declared as persistent using the db value
pragma, for example:


#pragma db value
class name
{
...

std::string first_;
std::string last_;
};


Note that a composite value cannot have a data member designated
as an object id since, as we have discussed earlier, values do
not have a notion of identity. A composite value type also doesn't
have to define the default constructor, unless it is used as an
element of a container. The ODB compiler uses the same mechanisms
to access data members in composite value types as in object types.
Composite value types are discussed in more detail in
Section 7.2, "Composite Value Types".

3.3 Object and View Pointers

As we have seen in the previous chapter, some database operations
create dynamically allocated instances of persistent classes and
return pointers to these instances. As we will see in later chapters,
pointers are also used to establish relationships between objects
(Chapter 6, "Relationships") as well as to cache
persistent objects in a session (Chapter 10,
"Session"). While in most cases you won't need to deal with
pointers to views, it is possible to a obtain a dynamically allocated
instance of a view using the result_iterator::load()
function (Section 4.4, "Query Results").

By default, all these mechanisms use raw pointers to return
objects and views as well as to pass and cache objects. This
is normally sufficient for applications
that have simple object lifetime requirements and do not use sessions
or object relationships. In particular, a dynamically allocated object
or view that is returned as a raw pointer from a database operation
can be assigned to a smart pointer of our choice, for example
std::auto_ptr, std::unique_ptr from C++11, or
shared_ptr from TR1, C++11, or Boost.

However, to avoid any possibility of a mistake, such as forgetting
to use a smart pointer for a returned object or view, as well as to
simplify the use of more advanced ODB functionality, such as sessions
and bidirectional object relationships, it is recommended that you use
smart pointers with the sharing semantics as object pointers.
The shared_ptr smart pointer from TR1, C++11, or Boost
is a good default choice. However, if sharing is not required and
sessions are not used, then std::unique_ptr or
std::auto_ptr can be used just as well.

ODB provides several mechanisms for changing the object or view pointer
type. To specify the pointer type on the per object or per view basis
we can use the db pointer pragma, for example:


#pragma db object pointer(std::tr1::shared_ptr)
class person
{
...
};


We can also specify the default pointer for a group of objects or
views at the namespace level:


#pragma db namespace pointer(std::tr1::shared_ptr)
namespace accounting
{
#pragma db object
class employee
{
...
};

#pragma db object
class employer
{
...
};
}


Finally, we can use the --default-pointer option to specify
the default pointer for the whole file. Refer to the
ODB
Compiler Command Line Manual for details on this option's argument.
The typical usage is shown below:


--default-pointer std::tr1::shared_ptr


An alternative to this method with the same effect is to specify the
default pointer for the global namespace:


#pragma db namespace() pointer(std::tr1::shared_ptr)


Note that we can always override the default pointer specified
at the namespace level or with the command line option using
the db pointer object or view pragma. For
example:


#pragma db object pointer(std::shared_ptr)
namespace accounting
{
#pragma db object
class employee
{
...
};

#pragma db object pointer(std::unique_ptr)
class employer
{
...
};
}


Refer to Section 12.1.2, "pointer
(object)", Section 12.2.4, "pointer
(view)", and Section 12.5.1, "pointer
(namespace)" for more information on these mechanisms.

Built-in support that is provided by the ODB runtime library allows us
to use shared_ptr (TR1 or C++11),
std::unique_ptr (C++11), or std::auto_ptr as
pointer types. Plus, ODB profile libraries, that are available for
commonly used frameworks and libraries (such as Boost and Qt),
provide support for smart pointers found in these frameworks and
libraries (Part III, "Profiles"). It is also
easy to add support for our own smart pointers, as described in
Section 6.5, "Using Custom Smart Pointers".

3.4 Database

Before an application can make use of persistence services
offered by ODB, it has to create a database class instance. A
database instance is the representation of the place where
the application stores its persistent objects. We create
a database instance by instantiating one of the database
system-specific classes. For example, odb::mysql::database
would be such a class for the MySQL database system. We will
also normally pass a database name as an argument to the
class' constructor. The following code fragment
shows how we can create a database instance for the MySQL
database system:


#include <odb/database.hxx>
#include <odb/mysql/database.hxx>

auto_ptr<odb::database> db (
new odb::mysql::database (
"test_user" // database login name
"test_password" // database password
"test_database" // database name
));


The odb::database class is a common interface for
all the database system-specific classes provided by ODB. You
would normally work with the database
instance via this interface unless there is a specific
functionality that your application depends on and which is
only exposed by a particular system's database
class. You will need to include the <odb/database.hxx>
header file to make this class available in your application.

The odb::database interface defines functions for
starting transactions and manipulating persistent objects.
These are discussed in detail in the remainder of this chapter
as well as the next chapter which is dedicated to the topic of
querying the database for persistent objects. For details on the
system-specific database classes, refer to
Part II, "Database Systems".

Before we can persist our objects, the corresponding database schema has
to be created in the database. The schema contains table definitions and
other relational database artifacts that are used to store the state of
persistent objects in the database.

There are several ways to create the database schema. The easiest is to
instruct the ODB compiler to generate the corresponding schema from the
persistent classes (--generate-schema option). The ODB
compiler can generate the schema as a standalone SQL file,
embedded into the generated C++ code, or as a separate C++ source file
(--schema-format option). If we are using the SQL file
to create the database schema, then this file should be executed,
normally only once, before the application is started.

Alternatively, if the schema is embedded directly into the generated
code or produced as a separate C++ source file, then we can use the
odb::schema_catalog class to create it in the database
from within our application, for example:


#include <odb/schema-catalog.hxx>

odb::transaction t (db->begin ());
odb::schema_catalog::create_schema (*db);
t.commit ();


Refer to the next section for information on the
odb::transaction class. The complete version of the above
code fragment is available in the schema/embedded example in
the odb-examples package.

The odb::schema_catalog class has the following interface.
You will need to include the <odb/schema-catalog.hxx>
header file to make this class available in your application.


namespace odb
{
class schema_catalog
{
public:
static void
create_schema (database&, const std::string& name = "");

static bool
exists (database_id, const std::string& name);

static bool
exists (const database&, const std::string& name)
};
}


The first argument to the create_schema() function
is the database instance that we would like to create the schema in.
The second argument is the schema name. By default, the ODB
compiler generates all embedded schemas with the default schema
name (empty string). However, if your application needs to
have several separate schemas, you can use the
--schema-name ODB compiler option to assign
custom schema names and then use these names as a second argument
to create_schema(). If the schema is not found,
create_schema() throws the
odb::unknown_schema exception. You can use the
exists() function to check whether a schema for the
specified database and with the specified name exists in the
catalog. Note also that the create_schema() function
should be called within a transaction.

Finally, we can also use a custom database schema with ODB. This approach
can work similarly to the standalone SQL file described above except that
the database schema is hand-written or produced by another program. Or we
could execute custom SQL statements that create the schema directly from
our application. To map persistent classes to custom database schemas, ODB
provides a wide range of mapping customization pragmas, such
as db table, db column,
and db type (Chapter 12, "ODB Pragma
Language"). For sample code that shows how to perform such mapping
for various C++ constructs, refer to the schema/custom
example in the odb-examples package.

3.5 Transactions

A transaction is an atomic, consistent, isolated and durable
(ACID) unit of work. Database operations can only be
performed within a transaction and each thread of execution
in an application can have only one active transaction at a
time.

By atomicity we mean that when it comes to making changes to
the database state within a transaction,
either all the changes are applied or none at all. Consider,
for example, a transaction that transfers funds between two
objects representing bank accounts. If the debit function
on the first object succeeds but the credit function on
the second fails, the transaction is rolled back and the
database state of the first object remains unchanged.

By consistency we mean that a transaction must take all the
objects stored in the database from one consistent state
to another. For example, if a bank account object must
reference a person object as its owner and we forget to
set this reference before making the object persistent,
the transaction will be rolled back and the database
will remain unchanged.

By isolation we mean that the changes made to the database
state during a transaction are only visible inside this
transaction until and unless it is committed. Using the
above example with the bank transfer, the results of the
debit operation performed on the first object is not
visible to other transactions until the credit operation
is successfully completed and the transaction is committed.

By durability we mean that once the transaction is committed,
the changes that it made to the database state are permanent
and will survive failures such as an application crash. From
now on the only way to alter this state is to execute and commit
another transaction.

A transaction is started by calling either the
database::begin() or connection::begin()
function. The returned transaction handle is stored in
an instance of the odb::transaction class.
You will need to include the <odb/transaction.hxx>
header file to make this class available in your application.
For example:


#include <odb/transaction.hxx>

transaction t (db.begin ())

// Perform database operations.

t.commit ();


The odb::transaction class has the following
interface:


namespace odb
{
class transaction
{
public:
typedef odb::database database_type;
typedef odb::connection connection_type;

transaction (transaction_impl*, bool make_current = true);

void
reset (transaction_impl*, bool make_current = true);

void
commit ();

void
rollback ();

database_type&
database ();

connection_type&
connection ();

static bool
has_current ();

static transaction&
current ();

static void
current (transaction&);

static bool
reset_current ();

// Callback API.
//
...
};
}


The commit() function commits a transaction and
rollback() rolls it back. Unless the transaction
has been finalized, that is, explicitly committed or rolled
back, the destructor of the transaction class will
automatically roll it back when the transaction instance goes
out of scope. If we try to commit or roll back a finalized
transaction, the odb::transaction_already_finalized
exception is thrown.

The database() accessor returns the database this
transaction is working on. Similarly, the connection()
accessor returns the database connection this transaction is on
(Section 3.6, "Connections").

The static current() accessor returns the
currently active transaction for this thread. If there is no active
transaction, this function throws the odb::not_in_transaction
exception. We can check whether there is a transaction in effect in
this thread using the has_current() static function.

The make_current argument in the transaction
constructor as well as the static current() modifier and
reset_current() function give us additional
control over the nomination of the currently active transaction.
If we pass false as the make_current
argument, then the newly created transaction will not
automatically be made the active transaction for this
thread. Later, we can use the static current() modifier
to set this transaction as the active transaction.
The reset_current() static function clears the
currently active transaction. Together, these mechanisms
allow for more advanced use cases, such as multiplexing
two or more transactions on the same thread. For example:


transaction t1 (db1.begin ()); // Active transaction.
transaction t2 (db2.begin (), false); // Not active.

// Perform database operations on db1.

transaction::current (t2); // Deactivate t1, activate t2.

// Perform database operations on db2.

transaction::current (t1); // Switch back to t1.

// Perform some more database operations on db1.

t1.commit ();

transaction::current (t2); // Switch to t2.

// Perform some more database operations on db2.

t2.commit ();


The reset() modifier allows us to reuse the same
transaction instance to complete several database
transactions. Similar to the destructor, reset()
will roll the current transaction back if it hasn't been finalized.
Here is how we can use this function to commit the current transaction
and start a new one every time a certain number of database operations
has been performed:


transaction t (db.begin ());

for (size_t i (0); i < n; ++i)
{
// Perform a database operation, such as persist an object.

// Commit the current transaction and start a new one after
// every 100 operations.
//
if (i % 100 == 0)
{
t.commit ();
t.reset (db.begin ());
}
}

t.commit ();


For more information on the transaction callback support, refer
to Section 13.1, "Transaction Callbacks".

Note that in the above discussion of atomicity, consistency,
isolation, and durability, all of those guarantees only apply
to the object's state in the database as opposed to the object's
state in the application's memory. It is possible to roll
a transaction back but still have changes from this
transaction in the application's memory. An easy way to
avoid this potential inconsistency is to instantiate
persistent objects only within the transaction scope. Consider,
for example, these two implementations of the same transaction:


void
update_age (database& db, person& p)
{
transaction t (db.begin ());

p.age (p.age () + 1);
db.update (p);

t.commit ();
}


In the above implementation, if the update() call fails
and the transaction is rolled back, the state of the person
object in the database and the state of the same object in the
application's memory will differ. Now consider an
alternative implementation which only instantiates the
person object for the duration of the transaction:


void
update_age (database& db, unsigned long id)
{
transaction t (db.begin ());

auto_ptr<person> p (db.load<person> (id));
p.age (p.age () + 1);
db.update (p);

t.commit ();
}


Of course, it may not always be possible to write the
application in this style. Oftentimes we need to access and
modify the application's state of persistent objects out of
transactions. In this case it may make sense to try to
roll back the changes made to the application state if
the transaction was rolled back and the database state
remains unchanged. One way to do this is to re-load
the object's state from the database, for example:


void
update_age (database& db, person& p)
{
try
{
transaction t (db.begin ());

p.age (p.age () + 1);
db.update (p);

t.commit ();
}
catch (...)
{
transaction t (db.begin ());
db.load (p.id (), p);
t.commit ();

throw;
}
}


See also Section 13.1, "Transaction Callbacks"
for an alternative approach.

3.6 Connections

The odb::connection class represents a connection
to the database. Normally, you wouldn't work with connections
directly but rather let the ODB runtime obtain and release
connections as needed. However, certain use cases may require
obtaining a connection manually. For completeness, this section
describes the connection class and discusses some
of its use cases. You may want to skip this section if you are
reading through the manual for the first time.

Similar to odb::database, the odb::connection
class is a common interface for all the database system-specific
classes provided by ODB. For details on the system-specific
connection classes, refer to Part II,
"Database Systems".

To make the odb::connection class available in your
application you will need to include the <odb/connection.hxx>
header file. The odb::connection class has the
following interface:


namespace odb
{
class connection
{
public:
typedef odb::database database_type;

transaction
begin () = 0;

unsigned long long
execute (const char* statement);

unsigned long long
execute (const std::string& statement);

unsigned long long
execute (const char* statement, std::size_t length);

database_type&
database ();
};

typedef details::shared_ptr<connection> connection_ptr;
}


The begin() function is used to start a transaction
on the connection. The execute() functions allow
us to execute native database statements on the connection.
Their semantics are equivalent to the database::execute()
functions (Section 3.12, "Executing Native SQL
Statements") except that they can be legally called outside
a transaction. Finally, the database() accessor
returns a reference to the odb::database instance
to which this connection corresponds.

To obtain a connection we call the database::connection()
function. The connection is returned as odb::connection_ptr,
which is an implementation-specific smart pointer with the shared
pointer semantics. This, in particular, means that the connection
pointer can be copied and returned from functions. Once the last
instance of connection_ptr pointing to the same
connection is destroyed, the connection is returned to the
database instance. The following code fragment
shows how we can obtain, use, and release a connection:


using namespace odb::core;

database& db = ...
connection_ptr c (db.connection ());

// Temporarily disable foreign key constraints.
//
c->execute ("SET FOREIGN_KEY_CHECKS = 0");

// Start a transaction on this connection.
//
transaction t (c->begin ());
...
t.commit ();

// Restore foreign key constraints.
//
c->execute ("SET FOREIGN_KEY_CHECKS = 1");

// When 'c' goes out of scope, the connection is returned to 'db'.


Some of the use cases which may require direct manipulation of
connections include out-of-transaction statement execution,
such as the execution of connection configuration statements,
the implementation of a connection-per-thread policy, and making
sure that a set of transactions is executed on the same
connection.

3.7 Error Handling and Recovery

ODB uses C++ exceptions to report database operation errors. Most
ODB exceptions signify hard errors or errors that cannot
be corrected without some intervention from the application.
For example, if we try to load an object with an unknown object
id, the odb::object_not_persistent exception is
thrown. Our application may be able to correct this error, for
instance, by obtaining a valid object id and trying again.
The hard errors and corresponding ODB exceptions that can be
thrown by each database function are described in the remainder
of this chapter with Section 3.14, "ODB Exceptions"
providing a quick reference for all the ODB exceptions.

The second group of ODB exceptions signify soft or
recoverable errors. Such errors are temporary
failures which normally can be corrected by simply re-executing
the transaction. ODB defines three such exceptions:
odb::connection_lost, odb::timeout,
and odb::deadlock. All recoverable ODB exceptions
are derived from the common odb::recoverable base
exception which can be used to handle all the recoverable
conditions with a single catch block.

The odb::connection_lost exception is thrown if
a connection to the database is lost in the middle of
a transaction. In this situation the transaction is aborted but
it can be re-tried without any changes. Similarly, the
odb::timeout exception is thrown if one of the
database operations or the whole transaction has timed out.
Again, in this case the transaction is aborted but can be
re-tried as is.

If two or more transactions access or modify more than one object
and are executed concurrently by different applications or by
different threads within the same application, then it is possible
that these transactions will try to access objects in an incompatible
order and deadlock. The canonical example of a deadlock are
two transactions in which the first has modified object1
and is waiting for the second transaction to commit its changes to
object2 so that it can also update object2.
At the same time the second transaction has modified object2
and is waiting for the first transaction to commit its changes to
object1 because it also needs to modify object1.
As a result, none of the two transactions can be completed.

The database system detects such situations and automatically
aborts the waiting operation in one of the deadlocked transactions.
In ODB this translates to the odb::deadlock
recoverable exception being thrown from one of the database functions.

The following code fragment shows how to handle the recoverable
exceptions by restarting the affected transaction:


const unsigned short max_retries = 5;

for (unsigned short retry_count (0); ; retry_count++)
{
try
{
transaction t (db.begin ());

...

t.commit ();
break;
}
catch (const odb::recoverable& e)
{
if (retry_count > max_retries)
throw retry_limit_exceeded (e.what ());
else
continue;
}
}


3.8 Making Objects Persistent

A newly created instance of a persistent class is transient.
We use the database::persist() function template
to make a transient instance persistent. This function has four
overloaded versions with the following signatures:


template <typename T>
typename object_traits<T>::id_type
persist (const T& object);

template <typename T>
typename object_traits<T>::id_type
persist (const object_traits<T>::const_pointer_type& object);

template <typename T>
typename object_traits<T>::id_type
persist (T& object);

template <typename T>
typename object_traits<T>::id_type
persist (const object_traits<T>::pointer_type& object);


Here and in the rest of the manual,
object_traits<T>::pointer_type and
object_traits<T>::const_pointer_type denote the
unrestricted and constant object pointer types (Section
3.3, "Object and View Pointers"), respectively.
Similarly, object_traits<T>::id_type denotes the object
id type. The odb::object_traits template is part of the
database support code generated by the ODB compiler.

The first persist() function expects a constant reference
to an instance being persisted. The second function expects a constant
object pointer. Both of these functions can only be used on objects with
application-assigned object ids (Section 12.4.2,
"auto").

The second and third persist() functions are similar to the
first two except that they operate on unrestricted references and object
pointers. If the identifier of the object being persisted is assigned
by the database, these functions update the id member of the passed
instance with the assigned value. All four functions return the object
id of the newly persisted object.

If the database already contains an object of this type with this
identifier, the persist() functions throw the
odb::object_already_persistent exception. This should
never happen for database-assigned object ids as long as the
number of objects persisted does not exceed the value space of
the id type.

When calling the persist() functions, we don't need to
explicitly specify the template type since it will be automatically
deduced from the argument being passed. The following example shows
how we can call these functions:


person john ("John", "Doe", 33);
shared_ptr<person> jane (new person ("Jane", "Doe", 32));

transaction t (db.begin ());

db.persist (john);
unsigned long jane_id (db.persist (jane));

t.commit ();

cerr << "Jane's id: " << jane_id << endl;


Notice that in the above code fragment we have created instances
that we were planning to make persistent before starting the
transaction. Likewise, we printed Jane's id after we have committed
the transaction. As a general rule, you should avoid performing
operations within the transaction scope that can be performed
before the transaction starts or after it terminates. An active
transaction consumes both your application's resources, such as
a database connection, as well as the database server's
resources, such as object locks. By following the above rule you
make sure these resources are released and made available to other
threads in your application and to other applications as soon as
possible.

3.9 Loading Persistent Objects

Once an object is made persistent, and you know its object id, it
can be loaded by the application using the database::load()
function template. This function has two overloaded versions with
the following signatures:


template <typename T>
typename object_traits<T>::pointer_type
load (const typename object_traits<T>::id_type& id);

template <typename T>
void
load (const typename object_traits<T>::id_type& id, T& object);


Given an object id, the first function allocates a new instance
of the object class in the dynamic memory, loads its state from
the database, and returns the pointer to the new instance. The
second function loads the object's state into an existing instance.
Both functions throw odb::object_not_persistent if
there is no object of this type with this id in the database.

When we call the first load() function, we need to
explicitly specify the object type. We don't need to do this for
the second function because the object type will be automatically
deduced from the second argument, for example:


transaction t (db.begin ());

auto_ptr<person> jane (db.load<person> (jane_id));

db.load (jane_id, *jane);

t.commit ();


In certain situations it may be necessary to reload the state
of an object from the database. While this is easy to achieve
using the second load() function, ODB provides
the database::reload() function template that
has a number of special properties. This function has two
overloaded versions with the following signatures:


template <typename T>
void
reload (T& object);

template <typename T>
void
reload (const object_traits<T>::pointer_type& object);


The first reload() function expects an object
reference, while the second expects an object pointer. Both
functions expect the id member in the passed object to contain
a valid object identifier and, similar to load(),
both will throw odb::object_not_persistent if
there is no object of this type with this id in the database.

The first special property of reload()
compared to the load() function is that it
does not interact with the session's object cache
(Section 10.1, "Object Cache"). That is, if
the object being reloaded is already in the cache, then it will
remain there after reload() returns. Similarly, if the
object is not in the cache, then reload() won't
put it there either.

The second special property of the reload() function
only manifests itself when operating on an object with the optimistic
concurrency model. In this case, if the states of the object
in the application memory and in the database are the same, then
no reloading will occur. For more information on optimistic
concurrency, refer to Chapter 11, "Optimistic
Concurrency".

If we don't know for sure whether an object with a given id
is persistent, we can use the find() function
instead of load(), for example:


template <typename T>
typename object_traits<T>::pointer_type
find (const typename object_traits<T>::id_type& id);

template <typename T>
bool
find (const typename object_traits<T>::id_type& id, T& object);


If an object with this id is not found in the database, the first
find() function returns a NULL pointer
while the second function leaves the passed instance unmodified and
returns false.

If we don't know the object id, then we can use queries to
find the object (or objects) matching some criteria
(Chapter 4, "Querying the Database"). Note,
however, that loading an object's state using its
identifier can be significantly faster than executing a query.


3.10 Updating Persistent Objects

If a persistent object has been modified, we can store the updated
state in the database using the database::update()
function template. This function has three overloaded versions with
the following signatures:


template <typename T>
void
update (const T& object);

template <typename T>
void
update (const object_traits<T>::const_pointer_type& object);

template <typename T>
void
update (const object_traits<T>::pointer_type& object);


The first update() function expects an object reference,
while the other two expect object pointers. If the object passed to
one of these functions does not exist in the database,
update() throws the odb::object_not_persistent
exception (but see a note on optimistic concurrency below).

Below is an example of the funds transfer that we talked about
in the earlier section on transactions. It uses the hypothetical
bank_account persistent class:


void
transfer (database& db,
unsigned long from_acc,
unsigned long to_acc,
unsigned int amount)
{
bank_account from, to;

transaction t (db.begin ());

db.load (from_acc, from);

if (from.balance () < amount)
throw insufficient_funds ();

db.load (to_acc, to);

to.balance (to.balance () + amount);
from.balance (from.balance () - amount);

db.update (to);
db.update (from);

t.commit ();
}


The same can be accomplished using dynamically allocated objects
and the update() function with object pointer argument,
for example:


transaction t (db.begin ());

shared_ptr<bank_account> from (db.load<bank_account> (from_acc));

if (from->balance () < amount)
throw insufficient_funds ();

shared_ptr<bank_account> to (db.load<bank_account> (to_acc));

to->balance (to->balance () + amount);
from->balance (from->balance () - amount);

db.update (to);
db.update (from);

t.commit ();


If any of the update() functions are operating on a
persistent class with the optimistic concurrency model, then they will
throw the odb::object_changed exception if the state of the
object in the database has changed since it was last loaded into the
application memory. Furthermore, for such classes, update()
no longer throws the object_not_persistent exception if
there is no such object in the database. Instead, this condition is
treated as a change of object state and object_changed
is thrown instead. For a more detailed discussion of optimistic
concurrency, refer to Chapter 11, "Optimistic
Concurrency".

In ODB, persistent classes, composite value types, as well as individual
data members can be declared read-only (see Section
12.1.4, "readonly (object)", Section
12.3.6, "readonly (composite value)", and
Section 12.4.12, "readonly
(data member)").

If an individual data member is declared read-only, then
any changes to this member will be ignored when updating the database
state of an object using any of the above update()
functions. A const data member is automatically treated
as read-only. If a composite value is declared read-only then all its
data members are treated as read-only.

If the whole object is declared read-only then the database state of
this object cannot be changed. Calling any of the above
update() functions for such an object will result in a
compile-time error.

3.11 Deleting Persistent Objects

To delete a persistent object's state from the database we use the
database::erase() or database::erase_query()
function templates. If the application still has an instance of the
erased object, this instance becomes transient. The erase()
function has the following overloaded versions:


template <typename T>
void
erase (const T& object);

template <typename T>
void
erase (const object_traits<T>::const_pointer_type& object);

template <typename T>
void
erase (const object_traits<T>::pointer_type& object);

template <typename T>
void
erase (const typename object_traits<T>::id_type& id);


The first erase() function uses an object itself, in
the form of an object reference, to delete its state from the
database. The next two functions accomplish the same result but using
object pointers. Note that all three functions leave the passed
object unchanged. It simply becomes transient. The last function
uses the object id to identify the object to be deleted. If the
object does not exist in the database, then all four functions
throw the odb::object_not_persistent exception
(but see a note on optimistic concurrency below).

We have to specify the object type when calling the last
erase() function. The same is unnecessary for the
first three functions because the object type will be automatically
deduced from their arguments. The following example shows how we
can call these functions:


person& john = ...
shared_ptr<jane> jane = ...
unsigned long joe_id = ...

transaction t (db.begin ());

db.erase (john);
db.erase (jane);
db.erase<person> (joe_id);

t.commit ();


If any of the erase() functions except the last one are
operating on a persistent class with the optimistic concurrency
model, then they will throw the odb::object_changed exception
if the state of the object in the database has changed since it was
last loaded into the application memory. Furthermore, for such
classes, erase() no longer throws the
object_not_persistent exception if there is no such
object in the database. Instead, this condition is treated as a
change of object state and object_changed is thrown
instead. For a more detailed discussion of optimistic concurrency,
refer to Chapter 11, "Optimistic Concurrency".

The erase_query() function allows us to delete
the state of multiple objects matching certain criteria. It uses
the query expression of the database::query() function
(Chapter 4, "Querying the Database") and,
because the ODB query facility is optional, it is only available
if the --generate-query ODB compiler option was
specified. The erase_query() function has the
following overloaded versions:


template <typename T>
unsigned long long
erase_query ();

template <typename T>
unsigned long long
erase_query (const odb::query<T>&);


The first erase_query() function is used to delete
the state of all the persistent objects of a given type stored
in the database. The second function uses the passed query instance
to only delete the state of objects matching the query criteria.
Both functions return the number of objects erased. When calling
the erase_query() function, we have to explicitly
specify the object type we are erasing. For example:


typedef odb::query<person> query;

transaction t (db.begin ());

db.erase_query<person> (query::last == "Doe" && query::age < 30);

t.commit ();


Unlike the query() function, when calling
erase_query() we cannot use members from pointed-to
objects in the query expression. However, we can still use
a member corresponding to a pointer as an ordinary object
member that has the id type of the pointed-to object
(Chapter 6, "Relationships"). This allows us
to compare object ids as well as test the pointer for
NULL. As an example, the following transaction
makes sure that all the employee objects that
reference an employer object that is about to
be deleted are deleted as well. Here we assume that the
employee class contains a pointer to the
employer class. Refer to Chapter 6,
"Relationships" for complete definitions of these
classes.


typedef odb::query<employee> query;

transaction t (db.begin ());

employer& e = ... // Employer object to be deleted.

db.erase_query<employee> (query::employer == e.id ());
db.erase (e);

t.commit ();



3.12 Executing Native SQL Statements

In some situations we may need to execute native SQL statements
instead of using the object-oriented database API described above.
For example, we may want to tune the database schema generated
by the ODB compiler or take advantage of a feature that is
specific to the database system we are using. The
database::execute() function, which has three
overloaded versions, provides this functionality:


unsigned long long
execute (const char* statement);

unsigned long long
execute (const std::string& statement);

unsigned long long
execute (const char* statement, std::size_t length)


The first execute() function expects the SQL statement
as a zero-terminated C-string. The last version expects the explicit
statement length as the second argument and the statement itself
may contain '\0' characters, for example, to represent
binary data, if the database system supports it. All three functions
return the number of rows that were affected by the statement. For
example:


transaction t (db.begin ());

db.execute ("DROP TABLE test");
db.execute ("CREATE TABLE test (n INT PRIMARY KEY)");

t.commit ();


While these functions must always be called within a transaction,
it may be necessary to execute a native statement outside a
transaction. This can be done using the
connection::execute() functions as described in
Section 3.6, "Connections".

3.13 Tracing SQL Statement Execution

Oftentimes it is useful to understand what SQL statements are
executed as a result of high-level database operations. For
example, we can use this information to figure out why certain
transactions don't produce desired results or why they take
longer than expected.

While this information can usually be obtained from the database
logs, ODB provides an application-side SQL statement tracing
support that is both more convenient and finer-grained.
For example, in a typical situation that calls for tracing
we would like to see the SQL statements executed as a result
of a specific transaction. While it may be difficult to
extract such a subset of statements from the database logs,
it is easy to achieve with ODB tracing support:


transaction t (db.begin ());
t.tracer (stderr_tracer);

...

t.commit ();


ODB allows us to specify a tracer on the database, connection,
and transaction levels. If specified for the database, then
all the statements executed on this database will be traced.
On the other hand, if a tracer is specified for the
connection, then only the SQL statements executed on this
connection will be traced. Similarly, a tracer specified
for a transaction will only show statements that are
executed as part of this transaction. All three classes
(odb::database, odb::connection,
and odb::transaction) provide the identical
tracing API:


void
tracer (odb::tracer&);

void
tracer (odb::tracer*);

odb::tracer*
tracer () const;


The first two tracer() functions allow us to set
the tracer object with the second one allowing us to clear the
current tracer by passing a NULL pointer. The
last tracer() function allows us to get the
current tracer object. It returns a NULL pointer
if there is no tracer in effect. Note that the tracing API
does not manage the lifetime of the tracer object. The tracer
should be valid for as long as it is being used. Furthermore,
the tracing API is not thread-safe. Trying to set a tracer
from multiple threads simultaneously will result in
undefined behavior.

The odb::tracer class defines a callback interface
that can be used to create custom tracer implementations. The
odb::stderr_tracer is a built-in tracer implementation
provided by the ODB runtime. It prints each executed SQL statement
to the standard error stream.

The odb::tracer class is defined in the
<odb/tracer.hxx> header file which you will need to
include in order to make this class available in your application.
The odb::tracer interface provided the following
callback functions:


namespace odb
{
class tracer
{
public:
virtual void
prepare (connection&, const statement&);

virtual void
execute (connection&, const statement&);

virtual void
execute (connection&, const char* statement) = 0;

virtual void
deallocate (connection&, const statement&);
};
}


The prepare() and deallocate() functions
are called when a prepared statement is created and destroyed,
respectively. The first execute() function is called
when a prepared statement is executed while the second one is called
when a normal statement is executed. The default implementations
for the prepare() and deallocate()
functions do nothing while the first execute() function
calls the second one passing the statement text as the second
argument. As a result, if all you are interested in are the
SQL statements being executed, then you only need to override the
second execute() function.

In addition to the common odb::tracer interface,
each database runtime provides a database-specific version
as odb::<database>::tracer. It has exactly
the same interface as the common version except that the
connection and statement types
are database-specific, which gives us access to additional,
database-specific information.

As an example, consider a more elaborate, PostgreSQL-specific
tracer implementation. Here we rely on the fact that the PostgreSQL
ODB runtime uses names to identify prepared statements and this
information can be obtained from the odb::pgsql::statement
object:


#include <odb/pgsql/tracer.hxx>
#include <odb/pgsql/database.hxx>
#include <odb/pgsql/connection.hxx>
#include <odb/pgsql/statement.hxx>

class pgsql_tracer: public odb::pgsql::tracer
{
virtual void
prepare (odb::pgsql::connection& c, const odb::pgsql::statement& s)
{
cerr << c.database ().db () << ": PREPARE " << s.name ()
<< " AS " << s.text () << endl;
}

virtual void
execute (odb::pgsql::connection& c, const odb::pgsql::statement& s)
{
cerr << c.database ().db () << ": EXECUTE " << s.name () << endl;
}

virtual void
execute (odb::pgsql::connection& c, const char* statement)
{
cerr << c.database ().db () << ": " << statement << endl;
}

virtual void
deallocate (odb::pgsql::connection& c, const odb::pgsql::statement& s)
{
cerr << c.database ().db () << ": DEALLOCATE " << s.name () << endl;
}
};


Note also that you can only set a database-specific tracer object
using a database-specific database instance, for example:


pgsql_tracer tracer;

odb::database& db = ...;
db.tracer (tracer); // Compile error.

odb::pgsql::database& db = ...;
db.tracer (tracer); // Ok.


3.14 ODB Exceptions

In the previous sections we have already mentioned some of the
exceptions that can be thrown by the database functions. In this
section we will discuss the ODB exception hierarchy and document
all the exceptions that can be thrown by the common ODB
runtime.

The root of the ODB exception hierarchy is the abstract
odb::exception class. This class derives
from std::exception and has the following
interface:


namespace odb
{
struct exception: std::exception
{
virtual const char*
what () const throw () = 0;
};
}


Catching this exception guarantees that we will catch all the
exceptions thrown by ODB. The what() function
returns a human-readable description of the condition that
triggered the exception.

The concrete exceptions that can be thrown by ODB are presented
in the following listing:


namespace odb
{
struct null_pointer: exception
{
virtual const char*
what () const throw ();
};

// Transaction exceptions.
//
struct already_in_transaction: exception
{
virtual const char*
what () const throw ();
};

struct not_in_transaction: exception
{
virtual const char*
what () const throw ();
};

struct transaction_already_finalized: exception
{
virtual const char*
what () const throw ();
};

// Session exceptions.
//
struct already_in_session: exception
{
virtual const char*
what () const throw ();
};

struct not_in_session: exception
{
virtual const char*
what () const throw ();
};

struct session_required: exception
{
virtual const char*
what () const throw ();
};

// Database operations exceptions.
//
struct recoverable: exception
{
};

struct connection_lost: recoverable
{
virtual const char*
what () const throw ();
};

struct timeout: recoverable
{
virtual const char*
what () const throw ();
};

struct deadlock: recoverable
{
virtual const char*
what () const throw ();
};

struct object_not_persistent: exception
{
virtual const char*
what () const throw ();
};

struct object_already_persistent: exception
{
virtual const char*
what () const throw ();
};

struct object_changed: exception
{
virtual const char*
what () const throw ();
};

struct result_not_cached: exception
{
virtual const char*
what () const throw ();
};

struct database_exception: exception
{
};

// Polymorphism support exceptions.
//
struct abstract_class: exception
{
virtual const char*
what () const throw ();
};

struct no_type_info: exception
{
virtual const char*
what () const throw ();
};

// Prepared query support exceptions.
//
struct prepared_already_cached: exception
{
const char*
name () const;

virtual const char*
what () const throw ();
};

struct prepared_type_mismatch: exception
{
const char*
name () const;

virtual const char*
what () const throw ();
};

// Schema catalog exceptions.
//
struct unknown_schema: exception
{
const std::string&
name () const;

virtual const char*
what () const throw ();
};
}


The null_pointer exception is thrown when a
pointer to a persistent object declared non-NULL
with the db not_null or
db value_not_null pragma has the NULL
value. See Chapter 6, "Relationships" for details.

The next three exceptions (already_in_transaction,
not_in_transaction,
transaction_already_finalized) are thrown by the
odb::transaction class and are discussed
in Section 3.5, "Transactions".

The next two exceptions (already_in_session, and
not_in_session) are thrown by the odb::session
class and are discussed in Chapter 10, "Session".

The session_required exception is thrown when ODB detects
that correctly loading a bidirectional object relationship requires a
session but one is not used. See Section 6.2,
"Bidirectional Relationships" for more information on this
exception.

The recoverable exception serves as a common base
for all the recoverable exceptions, which are: connection_lost,
timeout, and deadlock. The
connection_lost exception is thrown when a connection
to the database is lost. Similarly, the timeout exception
is thrown if one of the database operations or the whole transaction
has timed out. The deadlock exception is thrown when a
transaction deadlock is detected by the database system. These
exceptions can be thrown by any database function. See
Section 3.7, "Error Handling and Recovery"
for details.

The object_already_persistent exception is thrown
by the persist() database function. See
Section 3.8, "Making Objects Persistent"
for details.

The object_not_persistent exception is thrown
by the load(), update(), and
erase() database functions. Refer to
Section 3.9, "Loading Persistent Objects",
Section 3.10, "Updating Persistent Objects", and
Section 3.11, "Deleting Persistent Objects" for
more information.

The object_changed exception is thrown
by the update() database function and certain
erase() database functions when
operating on objects with the optimistic concurrency model. See
Chapter 11, "Optimistic Concurrency" for details.

The result_not_cached exception is thrown by
the query result class. Refer to Section 4.4,
"Query Result" for details.

The database_exception exception is a base class for all
database system-specific exceptions that are thrown by the
database system-specific runtime library. Refer to Part
II, "Database Systems" for more information.

The abstract_class exception is thrown by the database
functions when we attempt to persist, update, load, or erase an
instance of a polymorphic abstract class. For more information
on abstract classes, refer to Section 12.1.3,
"abstract".

The no_type_info exception is thrown by the database
functions when we attempt to persist, update, load, or erase an
instance of a polymorphic class for which no type information
is present in the application. This normally means that the
generated database support code for this class has not been
linked (or dynamically loaded) into the application or the
discriminator value has not been mapped to a persistent
class. For more information on polymorphism support, refer to
Section 8.2, "Polymorphism Inheritance".

The prepared_already_cached exception is thrown by the
cache_query() function if a prepared query with the
specified name is already cached. The prepared_type_mismatch
exception is thrown by the lookup_query() function if
the specified prepared query object type or parameters type
does not match the one in the cache. Refer to Section
4.5, "Prepared Queries" for details.

The unknown_schema exception is thrown by the
odb::schema_catalog class if a schema with the specified
name is not found. Refer to Section 3.4, "Database"
for details.

The odb::exception class is defined in the
<odb/exception.hxx> header file. All the
concrete ODB exceptions are defined in
<odb/exceptions.hxx> which also includes
<odb/exception.hxx>. Normally you don't
need to include either of these two headers because they are
automatically included by <odb/database.hxx>.
However, if the source file that handles ODB exceptions
does not include <odb/database.hxx>, then
you will need to explicitly include one of these headers.






4 Querying the Database

If we don't know the identifiers of the objects that we are looking
for, we can use queries to search the database for objects matching
certain criteria. The ODB query facility is optional and we need to
explicitly request the generation of the necessary database support
code with the --generate-query ODB compiler option.

ODB provides a flexible query API that offers two distinct levels of
abstraction from the database system query language such as SQL.
At the high level we are presented with an easy to use yet powerful
object-oriented query language, called ODB Query Language. This
query language is modeled after and is integrated into C++ allowing
us to write expressive and safe queries that look and feel like
ordinary C++. We have already seen examples of these queries in the
introductory chapters. Below is another, more interesting, example:


typedef odb::query<person> query;
typedef odb::result<person> result;

unsigned short age;
query q (query::first == "John" && query::age < query::_ref (age));

for (age = 10; age < 100; age += 10)
{
result r (db.query<person> (q));
...
}


At the low level, queries can be written as predicates using
the database system-native query language such as the
WHERE predicate from the SQL SELECT
statement. This language will be referred to as native query
language. At this level ODB still takes care of converting
query parameters from C++ to the database system format. Below
is the re-implementation of the above example using SQL as
the native query language:


query q ("first = 'John' AND age = " + query::_ref (age));


Note that at this level we lose the static typing of
query expressions. For example, if we wrote something like this:


query q (query::first == 123 && query::agee < query::_ref (age));


We would get two errors during the C++ compilation. The first would
indicate that we cannot compare query::first to an
integer and the second would pick the misspelling in
query::agee. On the other hand, if we wrote something
like this:


query q ("first = 123 AND agee = " + query::_ref (age));


It would compile fine and would trigger an error only when executed
by the database system.

We can also combine the two query languages in a single query, for
example:


query q ("first = 'John' AND" + (query::age < query::_ref (age)));


4.1 ODB Query Language

An ODB query is an expression that tells the database system whether
any given object matches the desired criteria. As such, a query expression
always evaluates as true or false. At
the higher level, an expression consists of other expressions
combined with logical operators such as && (AND),
|| (OR), and ! (NOT). For example:


typedef odb::query<person> query;

query q (query::first == "John" || query::age == 31);


At the core of every query expression lie simple expressions which
involve one or more object members, values, or parameters. To
refer to an object member we use an expression such as
query::first above. The names of members in the
query class are derived from the names of data members
in the object class by removing the common member name decorations,
such as leading and trailing underscores, the m_ prefix,
etc.

In a simple expression an object member can be compared to a value,
parameter, or another member using a number of predefined operators
and functions. The following table gives an overview of the available
expressions:




Operator
Description
Example



==
equal
query::age == 31



!=
unequal
query::age != 31



<
less than
query::age < 31



>
greater than
query::age > 31



<=
less than or equal
query::age <= 31



>=
greater than or equal
query::age >= 31



in()
one of the values
query::age.in (30, 32, 34)



in_range()
one of the values in range
query::age.in_range (begin, end)



is_null()
value is NULL
query::age.is_null ()



is_not_null()
value is not NULL
query::age.is_not_null ()



The in() function accepts a maximum of five arguments.
Use the in_range() function if you need to compare
to more than five values. This function accepts a pair of
standard C++ iterators and compares to all the values from
the begin position inclusive and until and
excluding the end position. The following
code fragment shows how we can use these functions:


std::vector<string> names;

names.push_back ("John");
names.push_back ("Jack");
names.push_back ("Jane");

query q1 (query::first.in ("John", "Jack", "Jane"));
query q2 (query::first.in_range (names.begin (), names.end ()));




The operator precedence in the query expressions are the same
as for equivalent C++ operators. We can use parentheses to
make sure the expression is evaluated in the desired order.
For example:


query q ((query::first == "John" || query::first == "Jane") &&
query::age < 31);



4.2 Parameter Binding

An instance of the odb::query class encapsulates two
parts of information about the query: the query expression and
the query parameters. Parameters can be bound to C++ variables
either by value or by reference.

If a parameter is bound by value, then the value for this parameter
is copied from the C++ variable to the query instance at the query
construction time. On the other hand, if a parameter is bound by
reference, then the query instance stores a reference to the
bound variable. The actual value of the parameter is only extracted
at the query execution time. Consider, for example, the following
two queries:


string name ("John");

query q1 (query::first == query::_val (name));
query q2 (query::first == query::_ref (name));

name = "Jane";

db.query<person> (q1); // Find John.
db.query<person> (q2); // Find Jane.


The odb::query class provides two special functions,
_val() and _ref(), that allow us to
bind the parameter either by value or by reference, respectively.
In the ODB query language, if the binding is not specified
explicitly, the value semantic is used by default. In the
native query language, binding must always be specified
explicitly. For example:


query q1 (query::age < age); // By value.
query q2 (query::age < query::_val (age)); // By value.
query q3 (query::age < query::_ref (age)); // By reference.

query q4 ("age < " + age); // Error.
query q5 ("age < " + query::_val (age)); // By value.
query q6 ("age < " + query::_ref (age)); // By reference.


A query that only has by-value parameters does not depend on any
other variables and is self-sufficient once constructed. A query
that has one or more by-reference parameters depends on the
bound variables until the query is executed. If one such variable
goes out of scope and we execute the query, the behavior is
undefined.

4.3 Executing a Query

Once we have the query instance ready and by-reference parameters
initialized, we can execute the query using the
database::query() function template. It has two
overloaded versions:


template <typename T>
result<T>
query (bool cache = true);

template <typename T>
result<T>
query (const odb::query<T>&, bool cache = true);


The first query() function is used to return all the
persistent objects of a given type stored in the database.
The second function uses the passed query instance to only return
objects matching the query criteria. The cache argument
determines whether the objects' states should be cached in the
application's memory or if they should be returned by the database
system one by one as the iteration over the result progresses. The
result caching is discussed in detail in the next section.

When calling the query() function, we have to
explicitly specify the object type we are querying. For example:


typedef odb::query<person> query;
typedef odb::result<person> result;

result all (db.query<person> ());
result johns (db.query<person> (query::first == "John"));


Note that it is not required to explicitly create a named
query variable before executing it. For example, the following
two queries are equivalent:


query q (query::first == "John");

result r1 (db.query<person> (q));
result r1 (db.query<person> (query::first == "John"));


Normally, we would create a named query instance if we are
planning to run the same query multiple times and would use the
in-line version for those that are executed only once (see also
Section 4.5, "Prepared Queries" for a more
optimal way to re-execute the same query multiple times). A named
query instance that does not have any by-reference parameters is
immutable and can be shared between multiple threads without
synchronization. On the other hand, a query instance with
by-reference parameters is modified every time it is executed.
If such a query is shared among multiple threads, then access
to this query instance must be synchronized from the execution
point and until the completion of the iteration over the result.

It is also possible to create queries from other queries by
combining them using logical operators. For example:


result
find_minors (database& db, const query& name_query)
{
return db.query<person> (name_query && query::age < 18);
}

result r (find_minors (db, query::first == "John"));


4.4 Query Result

The result of executing a query is zero, one, or more objects
matching the query criteria. The result is returned as an instance
of the odb::result class template, for example:


typedef odb::query<person> query;
typedef odb::result<person> result;

result johns (db.query<person> (query::first == "John"));


It is best to view an instance of odb::result
as a handle to a stream, such as a file stream. While we can
make a copy of a result or assign one result to another, the
two instances will refer to the same result stream. Advancing
the current position in one instance will also advance it in
another. The result instance is only usable within the transaction
it was created in. Trying to manipulate the result after the
transaction has terminated leads to undefined behavior.

The odb::result class template conforms to the
standard C++ sequence requirements and has the following
interface:


namespace odb
{
template <typename T>
class result
{
public:
typedef odb::result_iterator<T> iterator;

public:
result ();

result (const result&);

result&
operator= (const result&);

void
swap (result&)

public:
iterator
begin ();

iterator
end ();

public:
void
cache ();

bool
empty () const;

std::size_t
size () const;
};
}


The default constructor creates an empty result set. The
cache() function caches the returned objects'
state in the application's memory. We have already mentioned
result caching when we talked about query execution. As you
may remember the database::query() function
caches the result unless instructed not to by the caller.
The cache() function allows us to
cache the result at a later stage if it wasn't already
cached during query execution.

If the result is cached, the database state of all the returned
objects is stored in the application's memory. Note that
the actual objects are still only instantiated on demand
during result iteration. It is the raw database state that
is cached in memory. In contrast, for uncached results
the object's state is sent by the database system one object
at a time as the iteration progresses.

Uncached results can improve the performance of both the application
and the database system in situations where we have a large
number of objects in the result or if we will only examine
a small portion of the returned objects. However, uncached
results have a number of limitations. There can only be one
uncached result in a transaction. Creating another result
(cached or uncached) by calling database::query()
will invalidate the existing uncached result. Furthermore,
calling any other database functions, such as update()
or erase() will also invalidate the uncached result.

The empty() function returns true if
there are no objects in the result and false otherwise.
The size() function can only be called for cached results.
It returns the number of objects in the result. If we call this
function on an uncached result, the odb::result_not_cached
exception is thrown.

To iterate over the objects in a result we use the
begin() and end() functions
together with the odb::result<T>::iterator
type, for example:


result r (db.query<person> (query::first == "John"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
...
}


In C++11 we can use the auto-typed variabe instead
of spelling the iterator type explicitly, for example:


for (auto i (r.begin ()); i != r.end (); ++i)
{
...
}


The C++11 range-based for-loop can be used to further
simplify the iteration:


for (person& p: r)
{
...
}


The result iterator is an input iterator which means that the
only two position operations that it supports are to move to the
next object and to determine whether the end of the result stream
has been reached. In fact, the result iterator can only be in two
states: the current position and the end position. If we have
two iterators pointing to the current position and then we
advance one of them, the other will advance as well. This,
for example, means that it doesn't make sense to store an
iterator that points to some object of interest in the result
stream with the intent of dereferencing it after the iteration
is over. Instead, we would need to store the object itself.

The result iterator has the following dereference functions
that can be used to access the pointed-to object:


namespace odb
{
template <typename T>
class result_iterator
{
public:
T*
operator-> () const;

T&
operator* () const;

typename object_traits<T>::pointer_type
load ();

void
load (T& x);

typename object_traits<T>::id_type
id ();
};
}


When we call the * or -> operator,
the iterator will allocate a new instance of the object class
in the dynamic memory, load its state from the database
state, and return a reference or pointer to the new instance. The
iterator maintains the ownership of the returned object and will
return the same pointer for subsequent calls to either of these
operators until it is advanced to the next object or we call
the first load() function (see below). For example:


result r (db.query<person> (query::first == "John"));

for (result::iterator i (r.begin ()); i != r.end ();)
{
cout << i->last () << endl; // Create an object.
person& p (*i); // Reference to the same object.
cout << p.age () << endl;
++i; // Free the object.
}


The overloaded result_iterator::load() functions are
similar to database::load(). The first function
returns a dynamically allocated instance of the current
object. As an optimization, if the iterator already owns an object
as a result of an earlier
call to the * or -> operator, then it
relinquishes the ownership of this object and returns it instead.
This allows us to write code like this without worrying about
a double allocation:


result r (db.query<person> (query::first == "John"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
if (i->last == "Doe")
{
auto_ptr p (i.load ());
...
}
}


Note, however, that because of this optimization, a subsequent
to load() call to the * or ->
operator results in the allocation of a new object.

The second load() function allows
us to load the current object's state into an existing instance.
For example:


result r (db.query<person> (query::first == "John"));

person p;
for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
i.load (p);
cout << p.last () << endl;
cout << i.age () << endl;
}


The id() function return the object id of the current
object. While we can achieve the same by loading the object and getting
its id, this function is more efficient since it doesn't actually
create the object. This can be useful when all we need is the object's
identifier. For example:


std::set<unsigned long> set = ...; // Persons of interest.

result r (db.query<person> (query::first == "John"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
if (set.find (i.id ()) != set.end ()) // No object loaded.
{
cout << i->first () << endl; // Object loaded.
}
}



4.5 Prepared Queries

Most modern relational database systems have the notion of a prepared
statement. Prepared statements allow us to perform the potentially
expensive tasks of parsing SQL, preparing the query execution
plan, etc., once and then executing the same query multiple
times, potentially using different values for parameters in
each execution.

In ODB all the non-query database operations such as
persist(), load(), update(),
etc., are implemented in terms of prepared statements that are
cached and reused. While the query() database
operation also uses the prepared statement, this statement
is not cached or reused by default since ODB has no knowledge
of whether a query will be executed multiple times or only
once. Instead, ODB provides a mechanism, called prepared queries,
that allows us to prepare a query once and execute it multiple
times. In other words, ODB prepared queries are a thin wrapper
around the underlying database's prepared statement functionality.

In most cases ODB shields the application developer from database
connection management and multi-threading issues. However, when it
comes to prepared queries, a basic understanding of how ODB manages
these aspects is required. Conceptually, the odb::database
class represents a specific database, that is, a data store. However,
underneath, it maintains one or more connections to this database.
A connection can be used only by a single thread at a time. When
we start a transaction (by calling database::begin()),
the transaction instance obtains a connection and holds on to it
until the transaction is committed or rolled back. During this time
no other thread can use this connection. When the transaction
releases the connection, it may be closed or reused by another
transaction in this or another thread. What exactly happens to
a connection after it has been released depends on the connection
factory that is used by the odb::database instance.
For more information on connection factories, refer to
Part II, "Database Systems".

A query prepared on one connection cannot be executed on another.
In other words, a prepared query is associated with the connection.
One important implication of this restriction is that we cannot
prepare a query in one transaction and then try to execute it
in another without making sure that both transactions use the
same connection.

To enable the prepared query functionality we need to specify
the --generate-prepared ODB compiler option. If
we are planning to always prepare our queries, then we can
disable the once-off query execution support by also specifying
the --omit-unprepared option.

To prepare a query we use the prepare_query() function
template. This function can be called on both the odb::database
and odb::connection instances. The odb::database
version simply obtains the connection used by the currently active
transaction and calls the corresponding odb::connection
version. If no transaction is currently active, then this function
throws the odb::not_in_transaction exception
(Section 3.5, "Transactions"). The
prepare_query() function has the following signature:


template <typename T>
prepared_query<T>
prepare_query (const char* name, const odb::query<T>&);


The first argument to the prepare_query() function is
the prepared query name. This name is used as a key for prepared
query caching (discussed later) and must be unique. For some databases,
notably PostgreSQL, it is also used as a name of the underlying prepared
statement. The name "object_query" (for example,
"person_query") is reserved for the once-off queries
executed by the database::query() function. Note that
the prepare_query() function makes only a shallow copy
of this argument, which means that the name must be valid for the
lifetime of the returned prepared_query instance.

The second argument to the prepare_query() function
is the query criteria. It has the same semantics as in the
query() function discussed in Section
4.3, "Executing a Query". Similar to query(), we
also have to explicitly specify the object type that we will be
querying. For example:


typedef odb::query<person> query;
typedef odb::prepared_query<person> prep_query;

prep_query pq (
db.prepare_query<person> ("person-age-query", query::age > 50));


The result of executing the prepare_query() function is
the prepared_query instance that represent the prepared
query. It is best to view prepared_query as a handle to
the underlying prepared statement. While we can make a copy of it or
assign one prepared_query to another, the two instances
will refer to the same prepared statement. Once the last instance of
prepared_query referencing a specific prepared statement
is destroyed, this statement is released. The prepared_query
class template has the following interface:


namespace odb
{
template <typename T>
struct prepared_query
{
prepared_query ();

prepared_query (const prepared_query&)
prepared_query& operator= (const prepared_query&)

result<T>
execute (bool cache = true);

const char*
name () const;

statement&
statement () const;

operator unspecified_bool_type () const;
};
}


The default constructor creates an empty prepared_query
instance, that is, an instance that does not reference a prepared
statement and therefore cannot be executed. The only way to create
a non-empty prepared query is by calling the prepare_query()
function discussed above. To test whether the prepared query is empty,
we can use the implicit conversion operator to a boolean type. For
example:


prepared_query<person> pq;

if (pq)
{
// Not empty.
...
}


The execute() function executes the query and returns
the result instance. The cache argument indicates
whether the result should be cached and has the same semantics
as in the query() function. In fact, conceptually,
prepare_query() and execute() are just
the query() function split into two:
prepare_query() takes the first
query() argument (the query condition) while
execute() takes the second (the cache flag). Note
also that re-executing a prepared query invalidates the
previous execution result, whether cached or uncached.

The name() function returns the prepared query name.
This is the same name as was passed as the first argument in the
prepare_query() call. The statement()
function returns a reference to the underlying prepared statement.
Note also that calling any of these functions on an empty
prepared_query instance results in undefined behavior.

The simplest use-case for a prepared query is the need to
execute the same query multiple times within a single transaction.
Consider the following example that queries for people that are older
than a number of different ages. This and subsequent code fragments
are taken from the prepared example in the
odb-examples package.


typedef odb::query<person> query;
typedef odb::prepared_query<person> prep_query;
typedef odb::result<person> result;

transaction t (db.begin ());

unsigned short age;
query q (query::age > query::_ref (age));
prep_query pq (db.prepare_query<person> ("person-age-query", q));

for (age = 90; age > 40; age -= 10)
{
result r (pq.execute ());
...
}

t.commit ();


Another scenario is the need to reuse the same query in multiple
transactions that are executed at once. As was mentioned above,
in this case we need to make sure that the prepared query and
all the transactions use the same connection. Consider an
alternative version of the above example that executes each
query in a separate transaction:


connection_ptr conn (db.connection ());

unsigned short age;
query q (query::age > query::_ref (age));
prep_query pq (conn->prepare_query<person> ("person-age-query", q));

for (age = 90; age > 40; age -= 10)
{
transaction t (conn->begin ());

result r (pq.execute ());
...

t.commit ();
}



Note that with this approach we hold on to the database connection
until all the transactions involving the prepared query are
executed. In particular, this means that while we are busy, the
connection cannot be reused by another thread. Therefore, this
approach is only recommended if all the transactions are executed
close to each other. Also note that an uncached (see below)
prepared query is invalidated once we release the connection
on which it was prepared.

If we need to reuse a prepared query in transactions that are
executed at various times, potentially in different threads, then
the recommended approach is to cache the prepared query on the
connection. To support this functionality the odb::database
and odb::connection classes provide the following
function templates. Similar to prepare_query(),
the odb::database versions of the below
functions call the corresponding odb::connection
versions using the currently active transaction to resolve
the connection.


template <typename T>
void
cache_query (const prepared_query<T>&);

template <typename T, typename P>
void
cache_query (const prepared_query<T>&,
std::[auto|unique]_ptr<P> params);

template <typename T>
prepared_query<T>
lookup_query (const char* name) const;

template <typename T, typename P>
prepared_query<T>
lookup_query (const char* name, P*& params) const;


The cache_query() function caches the passed prepared
query on the connection. The second overloaded version of
cache_query() also takes a pointer to the
by-reference query parameters. In C++98/03 it should be
std::auto_ptr while in C++11 std::auto_ptr
or std::unique_ptr can be used. The
cache_query() function assumes ownership of the
passed params argument. If a prepared query
with the same name is already cached on this connection,
then the odb::prepared_already_cached exception
is thrown.

The lookup_query() function looks up a previously
cached prepared query given its name. The second overloaded
version of lookup_query() also returns a pointer
to the by-reference query parameters. If a prepared query
with this name has not been cached, then an empty
prepared_query instance is returned. If a
prepared query with this name has been cached but either
the object type or the parameters type does not match
that which was cached, then the odb::prepared_type_mismatch
exception is thrown.

As a first example of the prepared query cache functionality,
consider the case that does not use any by-reference parameters:


for (unsigned short i (0); i < 5; ++i)
{
transaction t (db.begin ());

prep_query pq (db.lookup_query<person> ("person-age-query"));

if (!pq)
{
pq = db.prepare_query<person> (
"person-val-age-query", query::age > 50);
db.cache_query (pq);
}

result r (pq.execute ());
...

t.commit ();

// Do some other work.
//
...
}


The following example shows how to do the same but for a query that
includes by-reference parameters. In this case the parameters are
cached together with the prepared query.


for (unsigned short age (90); age > 40; age -= 10)
{
transaction t (db.begin ());

unsigned short* age_param;
prep_query pq (
db.lookup_query<person> ("person-age-query", age_param));

if (!pq)
{
auto_ptr<unsigned short> p (new unsigned short);
age_param = p.get ();
query q (query::age > query::_ref (*age_param));
pq = db.prepare_query<person> ("person-age-query", q);
db.cache_query (pq, p); // Assumes ownership of p.
}

*age_param = age; // Initialize the parameter.
result r (pq.execute ());
...

t.commit ();

// Do some other work.
//
...
}


As is evident from the above examples, when we use a prepared
query cache, each transaction that executes a query must also
include code that prepares and caches this query if it hasn't already
been done. If a prepared query is used in a single place in the
application, then this is normally not an issue since all the
relevant code is kept in one place. However, if the same query
is used in several different places in the application, then
we may end up duplicating the same preparation and caching
code, which makes it hard to maintain.

To resolve this issue ODB allows us to register a prepared
query factory that will be called to prepare and cache a
query during the call to lookup_query(). To
register a factory we use the database::query_factory()
function. In C++98/03 it has the following signature:


void
query_factory (const char* name,
void (*factory) (const char* name, connection&));


While in C++11 it uses the std::function class
template:


void
query_factory (const char* name,
std::function<void (const char* name, connection&)>);


The first argument to the query_factory() function is
the prepared query name that this factory will be called to prepare
and cache. An empty name is treated as a fallback wildcard factory
that is capable of preparing any query. The second argument is the
factory function or, in C++11, function object or lambda.

The example fragment shows how we can use the prepared query
factory:


struct params
{
unsigned short age;
string first;
};

static void
query_factory (const char* name, connection& c)
{
auto_ptr<params> p (new params);
query q (query::age > query::_ref (p->age) &&
query::first == query::_ref (p->first));
prep_query pq (c.prepare_query<person> (name, q));
c.cache_query (pq, p);
}

db.query_factory ("person-age-name-query", &query_factory);

for (unsigned short age (90); age > 40; age -= 10)
{
transaction t (db.begin ());

params* p;
prep_query pq (db.lookup_query<person> ("person-age-name-query", p));
assert (pq);

p->age = age;
p->first = "John";
result r (pq.execute ());
...

t.commit ();
}


In C++11 we could have instead used a lambda function as well as
unique_ptr rather than auto_ptr:


db.query_factory (
"person-age-name-query",
[] (const char* name, connection& c)
{
unique_ptr<params> p (new params);
query q (query::age > query::_ref (p->age) &&
query::first == query::_ref (p->first));
prep_query pq (c.prepare_query<person> (name, q));
c.cache_query (pq, std::move (p));
});





5 Containers

The ODB runtime library provides built-in persistence support for all the
commonly used standard C++98/03 containers, namely,
std::vector, std::list, std::set,
std::multiset, std::map, and
std::multimap as well as C++11 std::array,
std::forward_list, std::unordered_set,
std::unordered_multiset, std::unordered_map,
and std::unordered_multimap.
Plus, ODB profile libraries, that are
available for commonly used frameworks and libraries (such as Boost and
Qt), provide persistence support for containers found in these frameworks
and libraries (Part III, "Profiles"). Both the
ODB runtime library and profile libraries also provide a number of
change-tracking container equivalents which can be used to minimize
the number of database operations necessary to synchronize the container
state with the database (Section 5.4, "Change-Tracking
Containers"). It is also easy to persist custom container types
as discussed later in Section 5.5, "Using Custom
Containers".

We don't need to do anything special to declare a member of a
container type in a persistent class. For example:


#pragma db object
class person
{
...
private:
std::vector<std::string> nicknames_;
...
};


The complete version of the above code fragment and the other code
samples presented in this chapter can be found in the container
example in the odb-examples package.

A data member in a persistent class that is of a container type
behaves like a value type. That is, when an object is made persistent,
the elements of the container are stored in the database. Similarly,
when a persistent object is loaded from the database, the contents
of the container are automatically loaded as well. A data member
of a container type can also use a smart pointer, as discussed
in Section 7.3, "Pointers and NULL
Value Semantics".

While an ordinary member is mapped to one or more columns in the
object's table, a member of a container type is mapped to a separate
table. The exact schema of such a table depends on the kind of
container. ODB defines the following container kinds: ordered,
set, multiset, map, and multimap. The container kinds and the
contents of the tables to which they are mapped are discussed
in detail in the following sections.

Containers in ODB can contain simple value types (Section
7.1, "Simple Value Types"), composite value types
(Section 7.2, "Composite Value Types"), and pointers
to objects (Chapter 6, "Relationships"). Containers of
containers, either directly or indirectly via a composite value
type, are not allowed. A key in a map or multimap container can
be a simple or composite value type but not a pointer to an object.
An index in the ordered container should be a simple integer value
type.

The value type in the ordered, set, and map containers as well as
the key type in the map containers should be default-constructible.
The default constructor in these types can be made private in which
case the odb::access class should be made a friend of
the value or key type. For example:


#pragma db value
class name
{
public:
name (const std::string&, const std::string&);
...
private:
friend class odb::access;
name ();
...
};

#pragma db object
class person
{
...
private:
std::vector<name> aliases_;
...
};



5.1 Ordered Containers

In ODB an ordered container is any container that maintains (explicitly
or implicitly) an order of its elements in the form of an integer index.
Standard C++ containers that are ordered include std::vector
and std::list as well as C++11 std::array and
std::forward_list. While elements in std::set
are also kept in a specific order, this order is not based on an
integer index but rather on the relationship between elements. As
a result, std::set is not considered an ordered
container for the purpose of persistence.

The database table for an ordered container consists of at least
three columns. The first column contains the object id of a
persistent class instance of which the container is a member.
The second column contains the element index within a container.
And the last column contains the element value. If the object
id or element value are composite, then, instead of a single
column, they can occupy multiple columns. For an ordered
container table the ODB compiler also defines two indexes:
one for the object id column(s) and the other for the index
column. Refer to Section 12.6, "Index Definition
Pragmas" for more information on how to customize these
indexes.

Consider the following persistent object as an example:


#pragma db object
class person
{
...
private:
#pragma db id auto
unsigned long id_;

std::vector<std::string> nicknames_;
...
};


The resulting database table (called person_nicknames) will
contain the object id column of type unsigned long
(called object_id), the index column of an integer type
(called index), and the value column of type
std::string (called value).

A number of ODB pragmas allow us to customize the table name, column
names, and native database types of an ordered container both, on
the per-container and per-member basis. For more information on
these pragmas, refer to Chapter 12, "ODB Pragma
Language". The following example shows some of the possible
customizations:


#pragma db object
class person
{
...
private:
#pragma db table("nicknames") \
id_column("person_id") \
index_type("SMALLINT UNSIGNED") \
index_column("nickname_number") \
value_type("VARCHAR(255)") \
value_column("nickname")
std::vector<std::string> nicknames_;
...
};


While the C++ container used in a persistent class may be ordered,
sometimes we may wish to store such a container in the database without
the order information. In the example above, for instance, the order
of person's nicknames is probably not important. To instruct the ODB
compiler to ignore the order in ordered containers we can use the
db unordered pragma (Section 12.3.9,
"unordered", Section 12.4.18,
"unordered"). For example:


#pragma db object
class person
{
...
private:
#pragma db unordered
std::vector<std::string> nicknames_;
...
};


The table for an ordered container that is marked unordered won't
have the index column and the order in which elements are retrieved
from the database may not be the same as the order in which they
were stored.

5.2 Set and Multiset Containers

In ODB set and multiset containers (referred to as just set
containers) are associative containers that contain elements
based on some relationship between them. A set container may
or may not guarantee a particular order of the elements that
it stores. Standard C++ containers that are considered set
containers for the purpose of persistence include
std::set and std::multiset as well
as C++11 std::unordered_set and
std::unordered_multiset.

The database table for a set container consists of at least
two columns. The first column contains the object id of a
persistent class instance of which the container is a member.
And the second column contains the element value. If the object
id or element value are composite, then, instead of a single
column, they can occupy multiple columns. ODB compiler also
defines an index on a set container table for the object id
column(s). Refer to Section 12.6, "Index Definition
Pragmas" for more information on how to customize this
index.

Consider the following persistent object as an example:


#pragma db object
class person
{
...
private:
#pragma db id auto
unsigned long id_;

std::set<std::string> emails_;
...
};


The resulting database table (called person_emails) will
contain the object id column of type unsigned long
(called object_id) and the value column of type
std::string (called value).

A number of ODB pragmas allow us to customize the table name,
column names, and native database types of a set container, both on
the per-container and per-member basis. For more information on
these pragmas, refer to Chapter 12, "ODB Pragma
Language". The following example shows some of the possible
customizations:


#pragma db object
class person
{
...
private:
#pragma db table("emails") \
id_column("person_id") \
value_type("VARCHAR(255)") \
value_column("email")
std::set<std::string> emails_;
...
};


5.3 Map and Multimap Containers

In ODB map and multimap containers (referred to as just map
containers) are associative containers that contain key-value
elements based on some relationship between keys. A map container
may or may not guarantee a particular order of the elements that
it stores. Standard C++ containers that are considered map
containers for the purpose of persistence include
std::map and std::multimap as well
as C++11 std::unordered_map and
std::unordered_multimap.

The database table for a map container consists of at least
three columns. The first column contains the object id of a
persistent class instance of which the container is a member.
The second column contains the element key. And the last column
contains the element value. If the object id, element key, or
element value are composite, then instead of a single column
they can occupy multiple columns. ODB compiler also
defines an index on a map container table for the object id
column(s). Refer to Section 12.6, "Index Definition
Pragmas" for more information on how to customize this
index.

Consider the following persistent object as an example:


#pragma db object
class person
{
...
private:
#pragma db id auto
unsigned long id_;

std::map<unsigned short, float> age_weight_map_;
...
};


The resulting database table (called person_age_weight_map)
will contain the object id column of type unsigned long
(called object_id), the key column of type
unsigned short (called key), and the value
column of type float (called value).

A number of ODB pragmas allow us to customize the table name,
column names, and native database types of a map container, both on
the per-container and per-member basis. For more information on
these pragmas, refer to Chapter 12, "ODB Pragma
Language". The following example shows some of the possible
customizations:


#pragma db object
class person
{
...
private:
#pragma db table("weight_map") \
id_column("person_id") \
key_type("INT UNSIGNED") \
key_column("age") \
value_type("DOUBLE") \
value_column("weight")
std::map<unsigned short, float> age_weight_map_;
...
};


5.4 Change-Tracking Containers

When a persistent object containing one of the standard containers
is updated in the database, ODB has no knowledge of which elements
were inserted, erased, or modified. As a result, ODB has no choice
but to assume the whole container has changed and update the state
of every single element. This can result in a significant overhead
if a container contains a large number of elements and we only
changed a small subset of them.

To eliminate this overhead, ODB provides a notion of change-tracking
containers. A change-tracking container, besides containing
its elements, just like an ordinary container, also includes the
change state for each element. When it is time to update such a
container in the database, ODB can use this change information to
perform a minimum number of database operations necessary to
synchronize the container state with the database.

The current version of the ODB runtime library provides a change-tracking
equivalent of std::vector (Section 5.4.1,
"Change-Tracking vector") with support for other
standard container equivalents planned for future releases. ODB
profile libraries also provide change-tracking equivalents for some
containers found in the corresponding frameworks and libraries
(Part III, "Profiles").

A change-tracking container equivalent can normally be used as a drop-in
replacement for an ordinary container except for a few minor
interface differences (discussed in the corresponding sub-sections).
In particular, we don't need to do anything extra to effect
change tracking. ODB will automatically start, stop, and reset
change tracking when necessary. The following example illustrates
this point using odb::vector as a replacement for
std::vector.


#pragma db object
class person
{
...

odb::vector<std::string> names;
};

person p; // No change tracking (not persistent).
p.names.push_back ("John Doe");

{
transaction t (db.begin ());
db.persist (p); // Start change tracking (persistent).
t.commit ();
}

p.names.push_back ("Johnny Doo");

{
transaction t (db.begin ());
db.update (p); // One INSERT; reset change state.
t.commit ();
}

p.names.modify (0) = "Doe, John"; // Instead of operator[].
p.names.pop_back ();

{
transaction t (db.begin ());
db.update (p); // One UPDATE, one DELETE; reset change state.
t.commit ();
}

{
transaction t (db.begin ());
auto_ptr<person> p1 (db.load<person> (...)); // Start change tracking.
p1->names.insert (p1->names.begin (), "Joe Do");
db.update (*p1); // One UPDATE, one INSERT; reset change state.
t.commit ();
}

{
transaction t (db.begin ());
db.erase (p); // One DELETE; stop change tracking (not persistent).
t.commit ();
}


One interesting aspect of change tracking is what happens when a
transaction that contains an update is later rolled back. In this
case, while the change-tracking container has reset the change
state (after update), actual changes were not committed to the
database. Change-tracking containers handle this case by
automatically registering a rollback callback and then, if it is
called, marking the container as "completely changed". In this
state, the container no longer tracks individual element changes
and, when updated, falls back to the complete state update, just
like an ordinary container. The following example illustrates
this point:


person p;
p.names.push_back ("John Doe");

{
transaction t (db.begin ());
db.persist (p); // Start change tracking (persistent).
t.commit ();
}

p.names.push_back ("Johnny Doo");

for (;;)
{
try
{
transaction t (db.begin ());

// First try: one INSERT.
// Next try: one DELETE, two INSERTs.
//
db.update (p); // Reset change state.

t.commit (); // If throws (rollback), mark as completely changed.
break;
}
catch (const odb::recoverable&)
{
continue;
}
}


5.4.1 Change-Tracking vector

Class template odb::vector, defined in
<odb/vector.hxx>, is a change-tracking
equivalent for std::vector. It
is implemented in terms of std::vector and is
implicit-convertible to and implicit-constructible from
const std::vector&. In particular, this
means that we can use odb::vector instance
anywhere const std::vector& is
expected. In addition, odb::vector constant
iterator (const_iterator) is the same type as
that of std::vector.

odb::vector incurs 2-bit per element overhead
in order to store the change state. It cannot
be stored unordered in the database (Section
12.4.18 "unordered") but can be used as an inverse
side of a relationship (6.2 "Bidirectional
Relationships"). In this case, no change tracking is performed
since no state for such a container is stored in the database.

The number of database operations required to update the state
of odb::vector corresponds well to the complexity
of std::vector functions. In particular, adding or
removing an element from the back of the vector (for example,
with push_back() and pop_back()),
requires only a single database statement execution. In contrast,
inserting or erasing an element somewhere in the middle of the
vector will require a database statement for every element that
follows it.

odb::vector replicates most of the std::vector
interface as defined in both C++98/03 and C++11 standards. However,
functions and operators that provide direct write access to
the elements had to be altered or disabled in order to support
change tracking. Additional functions used to interface with
std::vector and to control the change tracking state
were also added. The following listing summarizes the differences
between the odb::vector and std::vector
interfaces. Any std::vector function or operator
not mentioned in this listing has exactly the same signature
and semantics in odb::vector. Functions and
operators that were disabled are shown as commented out and
are followed by functions/operators that replace them.


namespace odb
{
template <class T, class A = std::allocator<T> >
class vector
{
...

// Element access.
//

//reference operator[] (size_type);
reference modify (size_type);

//reference at (size_type);
reference modify_at (size_type);

//reference front ();
reference modify_front ();

//reference back ();
reference modify_back ();

//T* data () noexcept;
T* modify_data () noexcept; // C++11 only.

// Iterators.
//
typedef typename std::vector<T, A>::const_iterator const_iterator;

class iterator
{
...

// Element Access.
//

//reference operator* () const;
const_reference operator* () const;
reference modify () const;

//pointer operator-> () const;
const_pointer operator-> () const;

//reference operator[] (difference_type);
const_reference operator[] (difference_type);
reference modify (difference_type) const;

// Interfacing with std::vector::iterator.
//
typename std::vector<T, A>::iterator base () const;
};

// Return std::vector iterators. The begin() functions mark
// all the elements as modified.
//
typename std::vector<T, A>::iterator mbegin ();
typename std::vector<T, A>::iterator mend ();
typename std::vector<T, A>::reverse_iterator mrbegin ();
typename std::vector<T, A>::reverse_iterator mrend ();

// Interfacing with std::vector.
//
vector (const std::vector<T, A>&);
vector (std::vector<T, A>&&); // C++11 only.

vector& operator= (const std::vector<T, A>&);
vector& operator= (std::vector<T, A>&&); // C++11 only.

operator const std::vector<T, A>& () const;
std::vector<T, A>& base ();
const std::vector<T, A>& base ();

// Change tracking.
//
bool _tracking () const;
void _start () const;
void _stop () const;
void _arm (transaction&) const;
};
}


The following example highlights some of the differences between
the two interfaces. std::vector versions are commented
out.


#include <vector>
#include <odb/vector.hxx>

void f (const std::vector<int>&);

odb::vector<int> v ({1, 2, 3});

f (v); // Ok, implicit conversion.

if (v[1] == 2) // Ok, const access.
//v[1]++;
v.modify (1)++;

//v.back () = 4;
v.modify_back () = 4;

for (auto i (v.begin ()); i != v.end (); ++i)
{
if (*i != 0) // Ok, const access.
//*i += 10;
i.modify () += 10;
}

std::sort (v.mbegin (), v.mend ());


Note also the subtle difference between copy/move construction
and copy/move assignment of odb::vector instances.
While copy/move constructor will copy/move both the elements as
well as their change state, in contrast, assignment is tracked
as any other change to the vector content.

5.5 Using Custom Containers

While the ODB runtime and profile libraries provide support for
a wide range of containers, it is also easy to persist custom
container types or make a change-tracking version out of one.

To achieve this you will need to implement the
container_traits class template specialization for
your container. First, determine the container kind (ordered, set,
multiset, map, or multimap) for your container type. Then use a
specialization for one of the standard C++ containers found in
the common ODB runtime library (libodb) as a base
for your own implementation.

Once the container traits specialization is ready for your container,
you will need to include it into the ODB compilation process using
the --odb-epilogue option and into the generated header
files with the --hxx-prologue option. As an example,
suppose we have a hash table container for which we have the traits
specialization implemented in the hashtable-traits.hxx
file. Then, we can create an ODB compiler options file for this
container and save it to hashtable.options:


# Options file for the hash table container.
#
--odb-epilogue '#include "hashtable-traits.hxx"'
--hxx-prologue '#include "hashtable-traits.hxx"'


Now, whenever we compile a header file that uses the hashtable
container, we can specify the following command line option to
make sure it is recognized by the ODB compiler as a container
and the traits file is included in the generated code:


--options-file hashtable.options







6 Relationships

Relationships between persistent objects are expressed with pointers or
containers of pointers. The ODB runtime library provides built-in support
for shared_ptr/weak_ptr (TR1 or C++11),
std::unique_ptr (C++11),
std::auto_ptr, and raw pointers. Plus, ODB profile
libraries, that are available for commonly used frameworks and libraries
(such as Boost and Qt), provide support for smart pointers found in these
frameworks and libraries (Part III, "Profiles"). It is
also easy to add support for a custom smart pointer as discussed later
in Section 6.5, "Using Custom Smart Pointers". Any
supported smart pointer can be used in a data member as long as it can be
explicitly constructed from the canonical object pointer
(Section 3.3, "Object and View Pointers"). For
example, we can use weak_ptr if the object pointer
is shared_ptr.

When an object containing a pointer to another object is loaded,
the pointed-to object is loaded as well. In some situations this
eager loading of the relationships is undesirable since it
can lead to a large number of otherwise unused objects being
instantiated from the database. To support finer control
over relationships loading, the ODB runtime and profile
libraries provide the so-called lazy versions of
the supported pointers. An object pointed-to by a lazy pointer
is not loaded automatically when the containing object is loaded.
Instead, we have to explicitly request the instantiation of the
pointed-to object. Lazy pointers are discussed in
detail in Section 6.4, "Lazy Pointers".

As a simple example, consider the following employee-employer
relationship. Code examples presented in this chapter
will use the shared_ptr and weak_ptr
smart pointers from the TR1 (std::tr1) namespace.


#pragma db object
class employer
{
...

#pragma db id
std::string name_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

std::string first_name_;
std::string last_name_;

shared_ptr<employer> employer_;
};


By default, an object pointer can be NULL. To
specify that a pointer always points to a valid object we can
use the not_null pragma (Section
12.4.6, "null/not_null") for
single object pointers and the value_not_null pragma
(Section
12.4.23, "value_null/value_not_null")
for containers of object pointers. For example:


#pragma db object
class employee
{
...

#pragma db not_null
shared_ptr<employer> current_employer_;

#pragma db value_not_null
std::vector<shared_ptr<employer> > previous_employers_;
};


In this case, if we perform a database operation on the
employee object and the current_employer_
pointer or one of the pointers stored in the
previous_employers_ container is NULL,
then the odb::null_pointer exception will be thrown.

We don't need to do anything special to establish or navigate a
relationship between two persistent objects, as shown in the
following code fragment:


// Create an employer and a few employees.
//
unsigned long john_id, jane_id;
{
shared_ptr<employer> er (new employer ("Example Inc"));
shared_ptr<employee> john (new employee ("John", "Doe"));
shared_ptr<employee> jane (new employee ("Jane", "Doe"));

john->employer_ = er;
jane->employer_ = er;

transaction t (db.begin ());

db.persist (er);
john_id = db.persist (john);
jane_id = db.persist (jane);

t.commit ();
}

// Load a few employee objects and print their employer.
//
{
session s;
transaction t (db.begin ());

shared_ptr<employee> john (db.load<employee> (john_id));
shared_ptr<employee> jane (db.load<employee> (jane_id));

cout << john->employer_->name_ << endl;
cout << jane->employer_->name_ << endl;

t.commit ();
}


The only notable line in the above code is the creation of a
session before the second transaction starts. As discussed in
Chapter 10, "Session", a session acts as a cache
of persistent objects.
By creating a session before loading the employee
objects we make sure that their employer_ pointers
point to the same employer object. Without a
session, each employee would have ended up pointing
to its own, private instance of the Example Inc employer.

As a general guideline, you should use a session when loading
objects that have pointers to other persistent objects. A
session makes sure that for a given object id, a single instance
is shared among all other objects that relate to it.

We can also use data members from pointed-to
objects in database queries (Chapter 4, "Querying the
Database"). For each pointer in a persistent class, the query
class defines a smart pointer-like member that contains members
corresponding to the data members in the pointed-to object. We
can then use the access via a pointer syntax (->)
to refer to data members in pointed-to objects.
For example, the query class for the employee object
contains the employer member (its name is derived from the
employer_ pointer) which in turn contains the
name member (its name is derived from the
employer::name_ data member of the pointed-to object).
As a result, we can use the query::employer->name
expression while querying the database for the employee
objects. For example, the following transaction finds all the
employees of Example Inc that have the Doe last name:


typedef odb::query<employee> query;
typedef odb::result<employee> result;

session s;
transaction t (db.begin ());

result r (db.query<employee> (
query::employer->name == "Example Inc" && query::last == "Doe"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
cout << i->first_ << " " << i->last_ << endl;

t.commit ();


A query class member corresponding to a non-inverse
(Section 6.2, "Bidirectional Relationships") object
pointer can also be used as a normal member that has the id type
of the pointed-to object. For example, the following query locates
all the employee objects that don't have an associated
employer object:


result r (db.query<employee> (query::employer.is_null ()));


An important concept to keep in mind when working with object
relationships is the independence of persistent objects. In particular,
when an object containing a pointer to another object is made persistent
or is updated, the pointed-to object is not automatically persisted
or updated. Rather, only a reference to the object (in the form of the
object id) is stored for the pointed-to object in the database.
The pointed-to object itself is a separate entity and should
be made persistent or updated independently.

When persisting or updating an object containing a pointer to another
object, the pointed-to object must have a valid object id. This,
however, may not always be easy to achieve in complex relationships that
involve objects with automatically assigned identifiers. In such
cases it may be necessary to first persist an object with a pointer
set to NULL and then, once the pointed-to object is
made persistent and its identifier assigned, set the pointer
to the correct value and update the object in the database.

Persistent object relationships can be divided into two groups:
unidirectional and bidirectional. Each group in turn contains
several configurations that vary depending on the cardinality
of the sides of the relationship. All possible unidirectional
and bidirectional configurations are discussed in the following
sections.

6.1 Unidirectional Relationships

In unidirectional relationships we are only interested in navigating
from object to object in one direction. Because there is no interest
in navigating in the opposite direction, the cardinality of the other
end of the relationship is unimportant. As a result, there are only
two possible unidirectional relationships: to-one and to-many. Each
of these relationships is described in the following sections. For
sample code that shows how to work with these relationships, refer
to the relationship example in the odb-examples
package.

6.1.1 To-One Relationships

An example of a unidirectional to-one relationship is the
employee-employer relationship (an employee has one employer).
The following persistent C++ classes model this relationship:


#pragma db object
class employer
{
...

#pragma db id
std::string name_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db not_null
shared_ptr<employer> employer_;
};


The corresponding database tables look like this:


CREATE TABLE employer (
name VARCHAR (255) NOT NULL PRIMARY KEY);

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
employer VARCHAR (255) NOT NULL REFERENCES employer (name));


6.1.2 To-Many Relationships

An example of a unidirectional to-many relationship is the
employee-project relationship (an employee can be involved
in multiple projects). The following persistent C++ classes
model this relationship:


#pragma db object
class project
{
...

#pragma db id
std::string name_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db value_not_null unordered
std::vector<shared_ptr<project> > projects_;
};


The corresponding database tables look like this:


CREATE TABLE project (
name VARCHAR (255) NOT NULL PRIMARY KEY);

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY);

CREATE TABLE employee_projects (
object_id BIGINT UNSIGNED NOT NULL,
value VARCHAR (255) NOT NULL REFERENCES project (name));


To obtain a more canonical database schema, the names of tables
and columns above can be customized using ODB pragmas
(Chapter 12, "ODB Pragma Language"). For example:


#pragma db object
class employee
{
...

#pragma db value_not_null unordered \
id_column("employee_id") value_column("project_name")
std::vector<shared_ptr<project> > projects_;
};


The resulting employee_projects table would then
look like this:


CREATE TABLE employee_projects (
employee_id BIGINT UNSIGNED NOT NULL,
project_name VARCHAR (255) NOT NULL REFERENCES project (name));



6.2 Bidirectional Relationships

In bidirectional relationships we are interested in navigating
from object to object in both directions. As a result, each
object class in a relationship contains a pointer to the other
object. If smart pointers are used, then a weak pointer should
be used as one of the pointers to avoid ownership cycles. For
example:


class employee;

#pragma db object
class position
{
...

#pragma db id
unsigned long id_;

weak_ptr<employee> employee_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db not_null
shared_ptr<position> position_;
};


Note that when we establish a bidirectional relationship, we
have to set both pointers consistently. One way to make sure
that a relationship is always in a consistent state is to
provide a single function that updates both pointers at the
same time. For example:


#pragma db object
class position: public enable_shared_from_this<position>
{
...

void
fill (shared_ptr<employee> e)
{
employee_ = e;
e->positions_ = shared_from_this ();
}

private:
weak_ptr<employee> employee_;
};

#pragma db object
class employee
{
...

private:
friend class position;

#pragma db not_null
shared_ptr<position> position_;
};


At the beginning of this chapter we examined how to use a session
to make sure a single object is shared among all other objects pointing
to it. With bidirectional relationships involving weak pointers the
use of a session becomes even more crucial. Consider the following
transaction that tries to load the position object
from the above example without using a session:


transaction t (db.begin ())
shared_ptr<position> p (db.load<position> (1));
...
t.commit ();


When we load the position object, the employee
object, which it points to, is also loaded. While employee
is initially stored as shared_ptr, it is then assigned to
the employee_ member which is weak_ptr. Once
the assignment is complete, the shared pointer goes out of scope
and the only pointer that points to the newly loaded
employee object is the employee_ weak
pointer. And that means the employee object is deleted
immediately after being loaded. To help avoid such pathological
situations ODB detects cases where a newly loaded object will
immediately be deleted and throws the odb::session_required
exception.

As the exception name suggests, the easiest way to resolve this
problem is to use a session:


session s;
transaction t (db.begin ())
shared_ptr<position> p (db.load<position> (1));
...
t.commit ();


In our example, the session will maintain a shared pointer to the
loaded employee object preventing its immediate
deletion. Another way to resolve this problem is to avoid
immediate loading of the pointed-to objects using lazy weak
pointers. Lazy pointers are discussed in Section 6.4,
"Lazy Pointers" later in this chapter.

Above, to model a bidirectional relationship in persistent classes,
we used two pointers, one in each object. While this is a natural
representation in C++, it does not translate to a canonical
relational model. Consider the database schema generated for
the above two classes:


CREATE TABLE position (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
employee BIGINT UNSIGNED REFERENCES employee (id));

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
position BIGINT UNSIGNED NOT NULL REFERENCES position (id));


While this database schema is valid, it is unconventional. We have
a reference from a row in the position table to a row
in the employee table. We also have a reference
from this same row in the employee table back to
the row in the position table. From the relational
point of view, one of these references is redundant since
in SQL we can easily navigate in both directions using just one
of these references.

To eliminate redundant database schema references we can use the
inverse pragma (Section 12.4.14,
"inverse") which tells the ODB compiler that
a pointer is the inverse side of a bidirectional relationship.
Either side of a relationship can be made inverse. For example:


#pragma db object
class position
{
...

#pragma db inverse(position_)
weak_ptr<employee> employee_;
};

#pragma db object
class employee
{
...

#pragma db not_null
shared_ptr<position> position_;
};


The resulting database schema looks like this:


CREATE TABLE position (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY);

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
position BIGINT UNSIGNED NOT NULL REFERENCES position (id));


As you can see, an inverse member does not have a corresponding
column (or table, in case of an inverse container of pointers)
and, from the point of view of database operations, is effectively
read-only. The only way to change a bidirectional relationship
with an inverse side is to set its direct (non-inverse)
pointer. Also note that an ordered container (Section
5.1, "Ordered Containers") of pointers that is an inverse side
of a bidirectional relationship is always treated as unordered
(Section 12.4.18, "unordered")
because the contents of such a container are implicitly built from
the direct side of the relationship which does not contain the
element order (index).

There are three distinct bidirectional relationships that we
will cover in the following sections: one-to-one, one-to-many,
and many-to-many. We will only talk about bidirectional
relationships with inverse sides since they result in canonical
database schemas. For sample code that shows how to work with
these relationships, refer to the inverse example
in the odb-examples package.

6.2.1 One-to-One Relationships

An example of a bidirectional one-to-one relationship is the
presented above employee-position relationship (an employee
fills one position and a position is filled by one employee).
The following persistent C++ classes model this relationship:


class employee;

#pragma db object
class position
{
...

#pragma db id
unsigned long id_;

#pragma db inverse(position_)
weak_ptr<employee> employee_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db not_null
shared_ptr<position> position_;
};


The corresponding database tables look like this:


CREATE TABLE position (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY);

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
position BIGINT UNSIGNED NOT NULL REFERENCES position (id));


If instead the other side of this relationship is made inverse,
then the database tables will change as follows:


CREATE TABLE position (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
employee BIGINT UNSIGNED REFERENCES employee (id));

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY);


6.2.2 One-to-Many Relationships

An example of a bidirectional one-to-many relationship is the
employer-employee relationship (an employer has multiple
employees and an employee is employed by one employer).
The following persistent C++ classes model this relationship:


class employee;

#pragma db object
class employer
{
...

#pragma db id
std::string name_;

#pragma db value_not_null inverse(employer_)
std::vector<weak_ptr<employee> > employees_
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db not_null
shared_ptr<employer> employer_;
};


The corresponding database tables differ significantly depending
on which side of the relationship is made inverse. If the one
side (employer) is inverse as in the code
above, then the resulting database schema looks like this:


CREATE TABLE employer (
name VARCHAR (255) NOT NULL PRIMARY KEY);

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
employer VARCHAR (255) NOT NULL REFERENCES employer (name));


If instead the many side (employee) of this
relationship is made inverse, then the database tables will change
as follows:


CREATE TABLE employer (
name VARCHAR (255) NOT NULL PRIMARY KEY);

CREATE TABLE employer_employees (
object_id VARCHAR (255) NOT NULL,
value BIGINT UNSIGNED NOT NULL REFERENCES employee (id));

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY);


6.2.3 Many-to-Many Relationships

An example of a bidirectional many-to-many relationship is the
employee-project relationship (an employee can work on multiple
projects and a project can have multiple participating employees).
The following persistent C++ classes model this relationship:


class employee;

#pragma db object
class project
{
...

#pragma db id
std::string name_;

#pragma db value_not_null inverse(projects_)
std::vector<weak_ptr<employee> > employees_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db value_not_null unordered
std::vector<shared_ptr<project> > projects_;
};


The corresponding database tables look like this:


CREATE TABLE project (
name VARCHAR (255) NOT NULL PRIMARY KEY);

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY);

CREATE TABLE employee_projects (
object_id BIGINT UNSIGNED NOT NULL,
value VARCHAR (255) NOT NULL REFERENCES project (name));


If instead the other side of this relationship is made inverse,
then the database tables will change as follows:


CREATE TABLE project (
name VARCHAR (255) NOT NULL PRIMARY KEY);

CREATE TABLE project_employees (
object_id VARCHAR (255) NOT NULL,
value BIGINT UNSIGNED NOT NULL REFERENCES employee (id));

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY);


6.3 Circular Relationships

A relationship between two persistent classes is circular if each
of them references the other. Bidirectional relationships are
always circular. A unidirectional relationship combined with
inheritance (Chapter 8, "Inheritance") can also
be circular. For example, the employee class could
derive from person which, in turn, could contain a
pointer to employee.

We don't need to do anything extra if persistent classes with
circular dependencies are defined in the same header
file. Specifically, ODB will make sure that the database tables
and foreign key constraints are created in the correct order. As a
result, unless you have good reasons not to, it is recommended that
you keep persistent classes with circular dependencies in the same
header file.

If you have to keep such classes in separate header files, then
there are two extra steps that you may need to take in order to
use these classes with ODB. Consider again the example from
Section 6.2.1, "One-to-One Relationships"
but this time with the classes defined in separate headers:


// position.hxx
//
class employee;

#pragma db object
class position
{
...

#pragma db id
unsigned long id_;

#pragma db inverse(position_)
weak_ptr<employee> employee_;
};



// employee.hxx
//
#include "position.hxx"

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db not_null
shared_ptr<position> position_;
};


Note that the position.hxx header contains only the forward
declaration for employee. While this is sufficient to
define a valid, from the C++ point of view, position class,
the ODB compiler needs to "see" the definitions of the pointed-to
persistent classes. There are several ways we can fulfil this
requirement. The easiest is to simply include employee.hxx
at the end of position.hxx:


// position.hxx
//
class employee;

#pragma db object
class position
{
...
};

#include "employee.hxx"


We can also limit this inclusion only to the time when
position.hxx is compiled with the ODB compiler:


// position.hxx
//

...

#ifdef ODB_COMPILER
# include "employee.hxx"
#endif


Finally, if we don't want to modify position.hxx,
then we can add employee.hxx to the ODB compilation
process with the --odb-epilogue option. For example:


odb ... --odb-epilogue "#include \"employee.hxx\"" position.hxx


Note also that in this example we didn't have to do anything extra
for employee.hxx because it already includes
position.hxx. However, if instead it relied only
on the forward declaration of the position class,
then we would have to handle it in the same way as
position.hxx.

The other difficulty with separately defined classes involving
circular relationships has to do with the correct order of foreign
key constraint creation in the generated database schema. In
the above example, if we generate the database schema as
standalone SQL files, then we will end up with two such files:
position.sql and employee.sql.
If we try to execute employee.sql first, then
we will get an error indicating that the table corresponding to
the position class and referenced by the foreign
key constraint corresponding to the position_
pointer does not yet exist.

Note that there is no such problem if the database schema
is embedded in the generated C++ code instead of being produced
as standalone SQL files. In this case, the ODB compiler is
able to ensure the correct creation order even if the classes
are defined in separate header files.

In certain cases, for example, a bidirectional relationship
with an inverse side, this problem can be resolved by executing
the database schema creation files in the correct order. In our
example, this would be position.sql first
and employee.sql second. However, this approach
doesn't scale beyond simple object models.

A more robust solution to this problem is to generate the database
schema for all the persistent classes into a single SQL file. This
way, the ODB compiler can again ensure the correct creation order
of tables and foreign keys. To instruct the ODB compiler to produce
a combined schema file for several headers we can use the
--generate-schema-only and --at-once
options. For example:


odb ... --generate-schema-only --at-once --output-name schema \
position.hxx employee.hxx


The result of the above command is a single schema.sql
file that contains the database creation code for both
position and employee classes.

6.4 Lazy Pointers

Consider again the bidirectional, one-to-many employer-employee
relationship that was presented earlier in this chapter:


class employee;

#pragma db object
class employer
{
...

#pragma db id
std::string name_;

#pragma db value_not_null inverse(employer_)
std::vector<weak_ptr<employee> > employees_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

#pragma db not_null
shared_ptr<employer> employer_;
};


Consider also the following transaction which obtains the employer
name given the employee id:


unsigned long id = ...
string name;

session s;
transaction t (db.begin ());

shared_ptr<employee> e (db.load<employee> (id));
name = e->employer_->name_;

t.commit ();


While this transaction looks very simple, it actually does a lot more
than what meets the eye and is necessary. Consider what happens when
we load the employee object: the employer_
pointer is also automatically loaded which means the employer
object corresponding to this employee is also loaded. But the
employer object in turn contains the list of pointers
to all the employees, which are also loaded. A a result, when object
relationships are involved, a simple transaction like the above can
load many more objects than is necessary.

To overcome this problem ODB offers finer grained control over
the relationship loading in the form of lazy pointers. A lazy
pointer does not automatically load the pointed-to object
when the containing object is loaded. Instead, we have to
explicitly load the pointed-to object if and when we need to
access it.

The ODB runtime library provides lazy counterparts for all the
supported pointers, namely:
odb::lazy_shared_ptr/lazy_weak_ptr
for C++11 std::shared_ptr/weak_ptr,
odb::tr1::lazy_shared_ptr/lazy_weak_ptr
for TR1 std::tr1::shared_ptr/weak_ptr,
odb::lazy_unique_ptr for C++11 std::unique_ptr,
odb::lazy_auto_ptr for std::auto_ptr,
and odb::lazy_ptr for raw pointers. The TR1 lazy
pointers are defined in the <odb/tr1/lazy-ptr.hxx>
header while all the others — in
<odb/lazy-ptr.hxx>. The ODB profile
libraries also provide lazy pointer implementations for smart pointers
from popular frameworks and libraries (Part III,
"Profiles").

While we will discuss the interface of lazy pointers in more detail
shortly, the most commonly used extra function provided by these
pointers is load(). This function loads the
pointed-to object if it hasn't already been loaded. After
the call to this function, the lazy pointer can be used
in the the same way as its eager counterpart. The load()
function also returns the eager pointer, in case you need to pass
it around. For a lazy weak pointer, the
load() function also locks the pointer.

The following example shows how we can change our employer-employee
relationship to use lazy pointers. Here we choose to use lazy pointers
for both sides of the relationship.


class employee;

#pragma db object
class employer
{
...

#pragma db value_not_null inverse(employer_)
std::vector<lazy_weak_ptr<employee> > employees_;
};

#pragma db object
class employee
{
...

#pragma db not_null
lazy_shared_ptr<employer> employer_;
};


And the transaction is changed like this:


unsigned long id = ...
string name;

session s;
transaction t (db.begin ());

shared_ptr<employee> e (db.load<employee> (id));
e->employer_.load ();
name = e->employer_->name_;

t.commit ();



As a general guideline we recommend that you make at least one side
of a bidirectional relationship lazy, especially for relationships
with a many side.

A lazy pointer implementation mimics the interface of its eager
counterpart which can be used once the pointer is loaded. It also
adds a number of additional functions that are specific to the
lazy loading functionality. Overall, the interface of a lazy
pointer follows this general outline:


template <class T>
class lazy_ptr
{
public:
//
// The eager pointer interface.
//

// Initialization/assignment from an eager pointer.
//
public:
template <class Y> lazy_ptr (const eager_ptr<Y>&);
template <class Y> lazy_ptr& operator= (const eager_ptr<Y>&);

// Lazy loading interface.
//
public:
// NULL loaded()
//
// true true NULL pointer to transient object
// false true valid pointer to persistent object
// true false unloaded pointer to persistent object
// false false valid pointer to transient object
//
bool loaded () const;

eager_ptr<T> load () const;

// Unload the pointer. For transient objects this function is
// equivalent to reset().
//
void unload () const;

// Initialization with a persistent loaded object.
//
template <class Y> lazy_ptr (database&, Y*);
template <class Y> lazy_ptr (database&, const eager_ptr<Y>&);

template <class Y> void reset (database&, Y*);
template <class Y> void reset (database&, const eager_ptr<Y>&);

// Initialization with a persistent unloaded object.
//
template <class ID> lazy_ptr (database&, const ID&);

template <class ID> void reset (database&, const ID&);

// Query object id and database of a persistent object.
//
template <class O /* = T */>
// C++11: template <class O = T>
object_traits<O>::id_type object_id () const;

odb::database& database () const;
};


In a lazy weak pointer interface, the load() function
returns the strong (shared) eager pointer. The following
transaction demonstrates the use of a lazy weak pointer based on
the employer and employee classes
presented earlier.


typedef std::vector<lazy_weak_ptr<employee> > employees;

session s;
transaction t (db.begin ());

shared_ptr<employer> er (db.load<employer> ("Example Inc"));
employees& es (er->employees ());

for (employees::iterator i (es.begin ()); i != es.end (); ++i)
{
// We are only interested in employees with object id less than
// 100.
//
lazy_weak_ptr<employee>& lwp (*i);

if (lwp.object_id<employee> () < 100)
// C++11: if (lwp.object_id () < 100)
{
shared_ptr<employee> e (lwp.load ()); // Load and lock.
cout << e->first_ << " " << e->last_ << endl;
}
}

t.commit ();


Notice that inside the for-loop we use a reference to the lazy
weak pointer instead of making a copy. This is not merely to
avoid a copy. When a lazy pointer is loaded, all other lazy
pointers that point to the same object do not automatically
become loaded (though an attempt to load such copies will
result in them pointing to the same object, provided the
same session is still in effect). By using a reference
in the above transaction we make sure that we load the
pointer that is contained in the employer
object. This way, if we later need to re-examine this
employee object, the pointer will already
be loaded.

As another example, suppose we want to add an employee
to Example Inc. The straightforward implementation of this
transaction is presented below:


session s;
transaction t (db.begin ());

shared_ptr<employer> er (db.load<employer> ("Example Inc"));
shared_ptr<employee> e (new employee ("John", "Doe"));

e->employer_ = er;
er->employees ().push_back (e);

db.persist (e);
t.commit ();


Notice here that we didn't have to update the employer object
in the database since the employees_ list of
pointers is an inverse side of a bidirectional relationship
and is effectively read-only, from the persistence point of
view.

A faster implementation of this transaction, that avoids loading
the employer object, relies on the ability to initialize an
unloaded lazy pointer with the database where the object
is stored as well as its identifier:


lazy_shared_ptr<employer> er (db, std::string ("Example Inc"));
shared_ptr<employee> e (new employee ("John", "Doe"));

e->employer_ = er;

session s;
transaction t (db.begin ());

db.persist (e);

t.commit ();


6.5 Using Custom Smart Pointers

While the ODB runtime and profile libraries provide support for
the majority of widely-used pointers, it is also easy to add
support for a custom smart pointer.

To achieve this you will need to implement the
pointer_traits class template specialization for
your pointer. The first step is to determine the pointer kind
since the interface of the pointer_traits specialization
varies depending on the pointer kind. The supported pointer kinds
are: raw (raw pointer or equivalent, that is, unmanaged),
unique (smart pointer that doesn't support sharing),
shared (smart pointer that supports sharing), and
weak (weak counterpart of the shared pointer). Any of
these pointers can be lazy, which also affects the
interface of the pointer_traits specialization.

Once you have determined the pointer kind for your smart pointer,
use a specialization for one of the standard pointers found in
the common ODB runtime library (libodb) as a base
for your own implementation.

Once the pointer traits specialization is ready, you will need to
include it into the ODB compilation process using the
--odb-epilogue option and into the generated header
files with the --hxx-prologue option. As an example,
suppose we have the smart_ptr smart pointer for which
we have the traits specialization implemented in the
smart-ptr-traits.hxx file. Then, we can create an ODB
compiler options file for this pointer and save it to
smart-ptr.options:


# Options file for smart_ptr.
#
--odb-epilogue '#include "smart-ptr-traits.hxx"'
--hxx-prologue '#include "smart-ptr-traits.hxx"'


Now, whenever we compile a header file that uses smart_ptr,
we can specify the following command line option to make sure it is
recognized by the ODB compiler as a smart pointer and the traits file
is included in the generated code:


--options-file smart-ptr.options


It is also possible to implement a lazy counterpart for your
smart pointer. The ODB runtime library provides a class template
that encapsulates the object id management and loading
functionality that is needed to implement a lazy pointer. All
you need to do is wrap it with an interface that mimics
your smart pointer. Using one of the existing lazy pointer
implementations (either from the ODB runtime library or one
of the profile libraries) as a base for your implementation
is the easiest way to get started.





7 Value Types

In Section 3.1, "Concepts and Terminology" we have
already discussed the notion of values and value types as well as the
distinction between simple and composite values. This chapter covers
simple and composite value types in more detail.

7.1 Simple Value Types

A simple value type is a fundamental C++ type or a class type that
is mapped to a single database column. For each supported database
system the ODB compiler provides a default mapping to suitable
database types for most fundamental C++ types, such as int
or float as well as some class types, such as
std::string. For more information about the default
mapping for each database system refer to Part II,
Database Systems. We can also provide a custom mapping for
these or our own value types using the db type
pragma (Section 12.3.1, "type").

7.2 Composite Value Types

A composite value type is a class or struct
type that is mapped to more than one database column. To declare
a composite value type we use the db value pragma,
for example:


#pragma db value
class basic_name
{
...

std::string first_;
std::string last_;
};


The complete version of the above code fragment and the other code
samples presented in this section can be found in the composite
example in the odb-examples package.

A composite value type does not have to define a default constructor,
unless it is used as an element of a container. In this case the
default constructor can be made private provided we also make the
odb::access class, defined in the
<odb/core.hxx> header, a friend of this value type.
For example:


#include <odb/core.hxx>

#pragma db value
class basic_name
{
public:
basic_name (const std::string& first, const std::string& last);

...

private:
friend class odb::access;

basic_name () {} // Needed for storing basic_name in containers.

...
};


The ODB compiler also needs access to the non-transient
(Section 12.4.11, "transient")
data members of a composite value type. It uses the same mechanisms
as for persistent classes which are discussed in
Section 3.2, "Declaring Persistent Objects and
Values".

The members of a composite value can be other value types (either
simple or composite), containers (Chapter 5,
"Containers"), and pointers to objects (Chapter 6,
"Relationships").
Similarly, a composite value type can be used in object members,
as an element of a container, and as a base for another composite
value type. In particular, composite value types can be used as
element types in set containers (Section 5.2, "Set
and Multiset Containers") and as key types in map containers
(Section 5.3, "Map and Multimap Containers").
A composite value type that is used as an element of a container
cannot contain other containers since containers of containers
are not allowed. The following example illustrates some of the
possible use cases:


#pragma db value
class basic_name
{
...

std::string first_;
std::string last_;
};

typedef std::vector<basic_name> basic_names;

#pragma db value
class name_extras
{
...

std::string nickname_;
basic_names aliases_;
};

#pragma db value
class name: public basic_name
{
...

std::string title_;
name_extras extras_;
};

#pragma db object
class person
{
...

name name_;
};


A composite value type can also be defined as an instantiation
of a C++ class template, for example:


template <typename T>
struct point
{
T x;
T y;
T z;
};

typedef point<int> int_point;
#pragma db value(int_point)

#pragma db object
class object
{
...

int_point center_;
};


Note that the database support code for such a composite value type
is generated when compiling the header containing the
db value pragma and not the header containing
the template definition or the typedef name. This
allows us to use templates defined in other files, such as
std::pair defined in the utility
standard header file:


#include <utility> // std::pair

typedef std::pair<std::string, std::string> phone_numbers;
#pragma db value(phone_numbers)

#pragma db object
class person
{
...

phone_numbers phone_;
};


We can also use data members from composite value types
in database queries (Chapter 4, "Querying the
Database"). For each composite value in a persistent class, the
query class defines a nested member that contains members corresponding
to the data members in the value type. We can then use the member access
syntax (.) to refer to data members in value types. For example, the
query class for the person object presented above
contains the name member (its name is derived from
the name_ data member) which in turn contains the
extras member (its name is derived from the
name::extras_ data member of the composite value type).
This process continues recursively for nested composite value types
and, as a result, we can use the query::name.extras.nickname
expression while querying the database for the person
objects. For example:


typedef odb::query<person> query;
typedef odb::result<person> result;

transaction t (db.begin ());

result r (db.query<person> (
query::name.extras.nickname == "Squeaky"));

...

t.commit ();


7.2.1 Composite Object Ids

An object id can be of a composite value type, for example:


#pragma db value
class name
{
...

std::string first_;
std::string last_;
};

#pragma db object
class person
{
...

#pragma db id
name name_;
};


However, a value type that can be used as an object id has a number
of restrictions. Such a value type cannot have container, object
pointer, or read-only data members. It also must be
default-constructible. Furthermore, if the persistent class in which
this composite value type is used as object id has session support
enabled (Chapter 10, "Session"), then it must also
implement the less-than comparison operator (operator<).

7.2.2 Composite Value Column and Table Names

Customizing a column name for a data member of a simple value
type is straightforward: we simply specify the desired name with
the db column pragma (Section
12.4.9, "column"). For composite value
types things are slightly more complex since they are mapped to
multiple columns. Consider the following example:


#pragma db value
class name
{
...

std::string first_;
std::string last_;
};

#pragma db object
class person
{
...

#pragma db id auto
unsigned long id_;

name name_;
};


The column names for the first_ and last_
members are constructed by using the sanitized name of the
person::name_ member as a prefix and the names of the
members in the value type (first_ and last_)
as suffixes. As a result, the database schema for the above classes
will look like this:


CREATE TABLE person (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
name_first TEXT NOT NULL,
name_last TEXT NOT NULL);


We can customize both the prefix and the suffix using the
db column pragma as shown in the following
example:


#pragma db value
class name
{
...

#pragma db column("first_name")
std::string first_;

#pragma db column("last_name")
std::string last_;
};

#pragma db object
class person
{
...

#pragma db column("person_")
name name_;
};


The database schema changes as follows:


CREATE TABLE person (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
person_first_name TEXT NOT NULL,
person_last_name TEXT NOT NULL);


We can also make the column prefix empty, for example:


#pragma db object
class person
{
...

#pragma db column("")
name name_;
};


This will result in the following schema:


CREATE TABLE person (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
first_name TEXT NOT NULL,
last_name TEXT NOT NULL);


The same principle applies when a composite value type is used
as an element of a container, except that instead of
db column, either the db value_column
(Section 12.4.31, "value_column") or
db key_column
(Section 12.4.30, "key_column")
pragmas are used to specify the column prefix.

When a composite value type contains a container, an extra table
is used to store its elements (Chapter 5, "Containers").
The names of such tables are constructed in a way similar to the
column names, except that by default both the object name and the
member name are used as a prefix. For example:


#pragma db value
class name
{
...

std::string first_;
std::string last_;
std::vector<std::string> nicknames_;
};

#pragma db object
class person
{
...

name name_;
};


The corresponding database schema will look like this:


CREATE TABLE person_name_nicknames (
object_id BIGINT UNSIGNED NOT NULL,
index BIGINT UNSIGNED NOT NULL,
value TEXT NOT NULL)

CREATE TABLE person (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
name_first TEXT NOT NULL,
name_last TEXT NOT NULL);


To customize the container table name we can use the
db table pragma (Section
12.4.19, "table"), for example:


#pragma db value
class name
{
...

#pragma db table("nickname")
std::vector<std::string> nicknames_;
};

#pragma db object
class person
{
...

#pragma db table("person_")
name name_;
};


This will result in the following schema changes:


CREATE TABLE person_nickname (
object_id BIGINT UNSIGNED NOT NULL,
index BIGINT UNSIGNED NOT NULL,
value TEXT NOT NULL)


Similar to columns, we can make the table prefix empty.


7.3 Pointers and NULL Value Semantics

Relational database systems have a notion of the special
NULL value that is used to indicate the absence
of a valid value in a column. While by default ODB maps
values to columns that do not allow NULL values,
it is possible to change that with the db null
pragma (Section 12.4.6,
"null/not_null").

To properly support the NULL semantics, the
C++ value type must have a notion of a NULL
value or a similar special state concept. Most basic
C++ types, such as int or std::string,
do not have this notion and therefore cannot be used directly
for NULL-enabled data members (in the case of a
NULL value being loaded from the database,
such data members will be default-initialized).

To allow the easy conversion of value types that do not support
the NULL semantics into the ones that do, ODB
provides the odb::nullable class template. It
allows us to wrap an existing C++ type into a container-like
class that can either be NULL or contain a
value of the wrapped type. ODB also automatically enables
the NULL values for data members of the
odb::nullable type. For example:


#include <odb/nullable.hxx>

#pragma db object
class person
{
...

std::string first_; // TEXT NOT NULL
odb::nullable<std::string> middle_; // TEXT NULL
std::string last_; // TEXT NOT NULL
};


The odb::nullable class template is defined
in the <odb/nullable.hxx> header file and
has the following interface:


namespace odb
{
template <typename T>
class nullable
{
public:
typedef T value_type;

nullable ();
nullable (const T&);
nullable (const nullable&);
template <typename Y> explicit nullable (const nullable<Y>&);

nullable& operator= (const T&);
nullable& operator= (const nullable&);
template <typename Y> nullable& operator= (const nullable<Y>&);

void swap (nullable&);

// Accessor interface.
//
bool null () const;

T& get ();
const T& get () const;

// Pointer interface.
//
operator bool_convertible () const;

T* operator-> ();
const T* operator-> () const;

T& operator* ();
const T& operator* () const;

// Reset to the NULL state.
//
void reset ();
};
}


The following example shows how we can use this interface:


nullable<string> ns;

// Using the accessor interface.
//
if (ns.null ())
{
s = "abc";
}
else
{
string s (ns.get ());
ns.reset ();
}

// The same using the pointer interface.
//
if (ns)
{
s = "abc";
}
else
{
string s (*ns);
ns.reset ();
}



The odb::nullable class template requires the wrapped
type to have public default and copy constructors as well as the
copy assignment operator. Note also that the odb::nullable
implementation is not the most efficient in that it always contains
a fully constructed value of the wrapped type. This is normally
not a concern for simple types such as the C++ fundamental
types or std::string. However, it may become
an issue for more complex types. In such cases you may want to
consider using a more efficient implementation of the
optional value concept such as the
optional class template from Boost
(Section 21.4, "Optional Library").

Another common C++ representation of a value that can be
NULL is a pointer. ODB will automatically
handle data members that are pointers to values, however,
it will not automatically enable NULL values
for such data members, as is the case for odb::nullable.
Instead, if the NULL value is desired, we will
need to enable it explicitly using the db null
pragma. For example:


#pragma db object
class person
{
...

std::string first_;

#pragma db null
std::auto_ptr<std::string> middle_;

std::string last_;
};


The ODB compiler includes built-in support for using
std::auto_ptr, std::unique_ptr (C++11),
and shared_ptr (TR1 or C++11) as pointers to values.
Plus, ODB profile libraries, that are
available for commonly used frameworks and libraries (such as Boost and
Qt), provide support for smart pointers found in these frameworks
and libraries (Part III, "Profiles").

ODB also supports the NULL semantics for composite
values. In the relational database the NULL composite
value is translated to NULL values for all the simple
data members of this composite value. For example:


#pragma db value
struct name
{
std::string first_;
odb::nullable<std::string> middle_;
std::string last_;
};

#pragma db object
class person
{
...
odb::nullable<name> name_;
};


ODB does not support the NULL semantics for containers.
This also means that a composite value that contains a container
cannot be NULL. With this limitation in mind, we can
still use smart pointers in data members of container types. The
only restriction is that these pointers must not be NULL.
For example:


#pragma db object
class person
{
...

std::auto_ptr<std::vector<std::string> > aliases_;
};







8 Inheritance

In C++ inheritance can be used to achieve two different goals.
We can employ inheritance to reuse common data and functionality
in multiple classes. For example:


class person
{
public:
const std::string& first () const;
const std::string& last () const;

private:
std::string first_;
std::string last_;
};

class employee: public person
{
...
};

class contractor: public person
{
...
};


In the above example both the employee and
contractor classes inherit the first_
and last_ data members as well as the first()
and last() accessors from the person base
class.

A common trait of this inheritance style, referred to as reuse
inheritance from now on, is the lack of virtual functions and
a virtual destructor in the base class. Also with this style the
application code is normally written in terms of the derived classes
instead of the base.

The second way to utilize inheritance in C++ is to provide polymorphic
behavior through a common interface. In this case the base class
defines a number of virtual functions and, normally, a virtual
destructor while the derived classes provide specific
implementations of these virtual functions. For example:


class person
{
public:
enum employment_status
{
unemployed,
temporary,
permanent,
self_employed
};

virtual employment_status
employment () const = 0;

virtual
~person ();
};

class employee: public person
{
public:
virtual employment_status
employment () const
{
return temporary_ ? temporary : permanent;
}

private:
bool temporary_;
};

class contractor: public person
{
public:
virtual employment_status
employment () const
{
return self_employed;
}
};


With this inheritance style, which we will call polymorphism
inheritance, the application code normally works with derived
classes via the base class interface. Note also that it is very common
to mix both styles in the same hierarchy. For example, the above two
code fragments can be combined so that the person base
class provides the common data members and functions as well as
defines the polymorphic interface.

The following sections describe the available strategies for
mapping reuse and polymorphism inheritance styles to a relational
data model. Note also that the distinction between the two styles is
conceptual rather than formal. For example, it is possible to treat
a class hierarchy that defines virtual functions as a case of reuse
inheritance if this results in the desired database mapping and
semantics.

Generally, classes that employ reuse inheritance are mapped to
completely independent entities in the database. They use different
object id spaces and should always be passed to and returned from
the database operations as pointers or references to derived types.
In other words, from the persistence point of view, such classes
behave as if the data members from the base classes were copied
verbatim into the derived ones.

In contrast, classes that employ polymorphism inheritance share
the object id space and can be passed to and returned from the
database operations polymorphically as pointers or
references to the base class.

For both inheritance styles it is sometimes desirable to prevent
instances of a base class from being stored in the database.
To achieve this a persistent
class can be declared abstract using the db abstract
pragma (Section 12.1.3, "abstract").
Note that a C++-abstract class, or a class that
has one or more pure virtual functions and therefore cannot be
instantiated, is also database-abstract. However, a
database-abstract class is not necessarily C++-abstract. The
ODB compiler automatically treats C++-abstract classes as
database-abstract.

8.1 Reuse Inheritance

Each non-abstract class from the reuse inheritance hierarchy is
mapped to a separate database table that contains all its data
members, including those inherited from base classes. An abstract
persistent class does not have to define an object id, nor a default
constructor, and it does not have a corresponding database table.
An abstract class cannot be a pointed-to object in a relationship.
Multiple inheritance is supported as long as each base
class is only inherited once. The following example shows a
persistent class hierarchy employing reuse inheritance:


// Abstract person class. Note that it does not declare the
// object id.
//
#pragma db object abstract
class person
{
...

std::string first_;
std::string last_;
};

// Abstract employee class. It derives from the person class and
// declares the object id for all the concrete employee types.
//
#pragma db object abstract
class employee: public person
{
...

#pragma db id auto
unsigned long id_;
};

// Concrete permanent_employee class. Note that it doesn't define
// any data members of its own.
//
#pragma db object
class permanent_employee: public employee
{
...
};

// Concrete temporary_employee class. It adds the employment
// duration in months.
//
#pragma db object
class temporary_employee: public employee
{
...

unsigned long duration_;
};

// Concrete contractor class. It derives from the person class
// (and not employee; an independent contractor is not considered
// an employee). We use the contractor's external email address
// as the object id.
//
#pragma db object
class contractor: public person
{
...

#pragma db id
std::string email_;
};


The sample database schema for this hierarchy is shown below.


CREATE TABLE permanent_employee (
first TEXT NOT NULL,
last TEXT NOT NULL,
id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT);

CREATE TABLE temporary_employee (
first TEXT NOT NULL,
last TEXT NOT NULL,
id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
duration BIGINT UNSIGNED NOT NULL);

CREATE TABLE contractor (
first TEXT NOT NULL,
last TEXT NOT NULL,
email VARCHAR (255) NOT NULL PRIMARY KEY);


The complete version of the code presented in this section is
available in the inheritance/reuse example in the
odb-examples package.

8.2 Polymorphism Inheritance

There are three general approaches to mapping a polymorphic
class hierarchy to a relational database. These are
table-per-hierarchy, table-per-difference,
and table-per-class. With the table-per-hierarchy
mapping, all the classes in a hierarchy are stored in a single,
"wide" table. NULL values are stored in columns
corresponding to data members of derived classes that are
not present in any particular instance.

In the table-per-difference mapping, each class is mapped
to a separate table. For a derived class, this table contains
only columns corresponding to the data members added by this
derived class.

Finally, in the table-per-class mapping, each class is mapped
to a separate table. For a derived class, this table contains
columns corresponding to all the data members, from this derived
class all the way down to the root of the hierarchy.

The table-per-difference mapping is generally considered as
having the best balance of flexibility, performance, and space
efficiency. It also results in a more canonical relational
database model compared to the other two approaches. As a
result, this is the mapping currently implemented in ODB.
Other mappings may be supported in the future.

A pointer or reference to an ordinary, non-polymorphic object
has just one type — the class type of that object. When we
start working with polymorphic objects, there are two types
to consider: the static type, or the declaration type
of a reference or pointer, and the object's actual or dynamic
type. An example will help illustrate the difference:


class person {...};
class employee: public person {...};

person p;
employee e;

person& r1 (p);
person& r2 (e);

auto_ptr<person> p1 (new employee);


In the above example, the r1 reference's both static
and dynamic types are person.
In contrast, the r2 reference's static type is
person while its dynamic type (the actual object
that it refers to) is employee. Similarly,
p1 points to the object of the person
static type but employee dynamic type.

In C++, the primary mechanisms for working with polymorphic objects
are virtual functions. We call a virtual function only knowing the
object's static type, but the version corresponding to the object's
dynamic type is automatically executed. This is the essence of
runtime polymorphism support in C++: we can operate in terms of a base
class interface but get the derived class' behavior. Similarly, the
essence of the runtime polymorphism support in ODB is to allow us to
persist, load, update, and query in terms of the base class interface
but have the derived class actually stored in the database.

To declare a persistent class as polymorphic we use the
db polymorphic pragma. We only need to
declare the root class of a hierarchy as polymorphic; ODB will
treat all the derived classes as polymorphic automatically. For
example:


#pragma db object polymorphic
class person
{
...

virtual
~person () = 0; // Automatically abstract.

#pragma db id auto
unsigned long id_;

std::string first_;
std::string last_;
};

#pragma db object
class employee: public person
{
...

bool temporary_;
};

#pragma db object
class contractor: public person
{

std::string email_;
};


A persistent class hierarchy declared polymorphic must also be
polymorphic in the C++ sense, that is, the root class must
declare or inherit at least one virtual function. It is
recommended that the root class also declares a virtual destructor.
The root class of the polymorphic hierarchy must contain
the data member designated as object id (a persistent class
without an object id cannot be polymorphic). Note also that,
unlike reuse inheritance, abstract polymorphic classes have
a table in the database, just like non-abstract classes.

Persistent classes in the same polymorphic hierarchy must use the
same kind of object pointer (Section 3.3,
"Object and View Pointers"). If the object pointer
for the root class is specified as a template or using the
special raw pointer syntax (*), then the ODB
compiler will automatically use the same object pointer
for all the derived classes. For example:


#pragma db object polymorphic pointer(std::shared_ptr)
class person
{
...
};

#pragma db object // Object pointer is std::shared_ptr<employee>.
class employee: public person
{
...
};

#pragma db object // Object pointer is std::shared_ptr<contractor>.
class contractor: public person
{
...
};


Similarly, if we enable or disable session support
(Chapter 10, "Session") for the root class, then
the ODB compiler will automatically enable or disable it for all
the derived classes.

For polymorphic persistent classes, all the database operations can
be performed on objects with different static and dynamic types.
Similarly, operations that load persistent objects from the
database (load(), query(), etc.), can
return objects with different static and dynamic types. For
example:


unsigned long id1, id2;

// Persist.
//
{
shared_ptr<person> p1 (new employee (...));
shared_ptr<person> p2 (new contractor (...));

transaction t (db.begin ());
id1 = db.persist (p1); // Stores employee.
id2 = db.persist (p2); // Stores contractor.
t.commit ();
}

// Load.
//
{
shared_ptr<person> p;

transaction t (db.begin ());
p = db.load<person> (id1); // Loads employee.
p = db.load<person> (id2); // Loads contractor.
t.commit ();
}

// Query.
//
{
typedef odb::query<person> query;
typedef odb::result<person> result;

transaction t (db.begin ());

result r (db.query<person> (query::last == "Doe"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
person& p (*i); // Can be employee or contractor.
}

t.commit ();
}

// Update.
//
{
shared_ptr<person> p;
shared_ptr<employee> e;

transaction t (db.begin ());

e = db.load<employee> (id1);
e->temporary (false);
p = e;
db.update (p); // Updates employee.

t.commit ();
}

// Erase.
//
{
shared_ptr<person> p;

transaction t (db.begin ());
p = db.load<person> (id1); // Loads employee.
db.erase (p); // Erases employee.
db.erase<person> (id2); // Erases contractor.
t.commit ();
}



The table-per-difference mapping, as supported by ODB, requires
two extra columns, in addition to those corresponding to the
data members. The first, called discriminator, is added
to the table corresponding to the root class of the hierarchy.
This column is used to determine the dynamic type of each
object. The second column is added to tables corresponding
to the derived classes and contains the object id. This
column is used to form a foreign key constraint referencing
the root class table.

When querying the database for polymorphic objects, it is
possible to obtain the discriminator value without
instantiating the object. For example:


typedef odb::query<person> query;
typedef odb::result<person> result;

transaction t (db.begin ());

result r (db.query<person> (query::last == "Doe"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
std::string d (i.discriminator ());
...
}

t.commit ();


In the current implementation, ODB has limited support for
customizing names, types, and values of the extra columns.
Currently, the discriminator column is always called
typeid and contains a namespace-qualified class
name (for example, "employee" or
"hr::employee"). The id column in the derived
class table has the same name as the object id column in
the root class table. Future versions of ODB will add support
for customizing these extra columns.

The sample database schema for the above polymorphic hierarchy
is shown below.


CREATE TABLE person (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
typeid VARCHAR(255) NOT NULL,
first TEXT NOT NULL,
last TEXT NOT NULL);

CREATE TABLE employee (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
temporary TINYINT(1) NOT NULL,

CONSTRAINT employee_id_fk
FOREIGN KEY (id)
REFERENCES person (id)
ON DELETE CASCADE);

CREATE TABLE contractor (
id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
email TEXT NOT NULL,

CONSTRAINT contractor_id_fk
FOREIGN KEY (id)
REFERENCES person (id)
ON DELETE CASCADE);


The complete version of the code presented in this section is
available in the inheritance/polymorphism example
in the odb-examples package.

8.2.1 Performance and Limitations

A database operation on a non-polymorphic object normally translates
to a single database statement execution (objects with containers
and eager object pointers can be the exception). Because polymorphic
objects have their data members
stored in multiple tables, some database operations on such objects
may result in multiple database statements being executed while others
may require more complex statements. There is also some functionality
that is not available to polymorphic objects.

The first part of this section discusses the performance implications
to keep in mind when designing and working with polymorphic hierarchies.
The second part talks about limitations of polymorphic objects.

The most important aspect of a polymorphic hierarchy that
affects database performance is its depth. The distance between
the root of the hierarchy and the derived class translates
directly to the number of database statements that will have to
be executed in order to persist, update, or erase this derived class.
It also translates directly to the number of SQL JOIN
clauses that will be needed to load or query the database for this
derived class. As a result, to achieve best performance, we should
try to keep our polymorphic hierarchies as flat as possible.

When loading an object or querying the database for objects,
ODB will need to execute two statements if this object's static
and dynamic types are different but only one statement if
they are the same. This example will help illustrate the
difference:


unsigned long id;

{
employee e (...);

transaction t (db.begin ());
id = db.persist (e);
t.commit ();
}

{
shared_ptr<person> p;

transaction t (db.begin ());
p = db.load<person> (id); // Requires two statement.
p = db.load<employee> (id); // Requires only one statement.
t.commit ();
}


As a result, we should try to load and query using the most
derived class possible.

Finally, for polymorphic objects, erasing via the object instance
is faster than erasing via its object id. In the former case the
object's dynamic type can be determined locally in the application
while in the latter case an extra statement has to be executed to
achieve the same result. For example:


shared_ptr<person> p = ...;

transaction t (db.begin ());
db.erase<person> (p.id ()); // Slower (executes extra statement).
db.erase (p); // Faster.
t.commit ();


Polymorphic objects can use all the mechanisms that are available
to ordinary objects. These include containers (Chapter 5,
"Containers"), object relationships, including to polymorphic
objects (Chapter 6, "Relationships"), views
(Chapter 9, "Views"), session (Chapter
10, "Session"), and optimistic concurrency (Chapter
11, "Optimistic Concurrency"). There are, however, a few
limitations, mainly due to the underlying use of SQL to access the
data.

When a polymorphic object is "joined" in a view, and the join
condition (either in the form of an object pointer or a custom
condition) comes from the object itself (as opposed to one of
the objects joined previously), then this condition must only
use data members from the derived class. For example, consider
the following polymorphic object hierarchy and a view:



#pragma db object polymorphic
class employee
{
...
};

#pragma db object
class permanent_employee: public employee
{
...
};

#pragma db object
class temporary_employee: public employee
{
...

shared_ptr<permanent_employee> manager_;
};

#pragma db object
class contractor: public temporary_employee
{
shared_ptr<permanent_employee> manager_;
};

#pragma db view object(permanent_employee) \
object(contractor: contractor::manager_)
struct contractor_manager
{
...
};


This view will not function correctly because the join condition
(manager_) comes from the base class
(temporary_employee) instead of the derived
(contractor). The reason for this limitation is the
JOIN clause order in the underlying SQL SELECT
statement. In the view presented above, the table corresponding
to the base class (temporary_employee) will have to
be joined first which will result in this view matching both
the temporary_employee and contractor
objects instead of just contractor. It is usually
possible to resolve this issue by reordering the objects in the
view. Our example, for instance, can be fixed by swapping the
two objects:


#pragma db view object(contractor) \
object(permanent_employee: contractor::manager_)
struct contractor_manager
{
...
};


The erase_query() database function (Section
3.11, "Deleting Persistent Objects") also has limited functionality
when used on polymorphic objects. Because many database implementations
do not support JOIN clauses in the SQL DELETE
statement, only data members from the derived class being erased can
be used in the query condition. For example:


typedef odb::query<employee> query;

transaction t (db.begin ());
db.erase_query<employee> (query::permanent); // Ok.
db.erase_query<employee> (query::last == "Doe"); // Error.
t.commit ();


8.3 Mixed Inheritance

It is possible to mix the reuse and polymorphism inheritance
styles in the same hierarchy. In this case, the reuse inheritance
must be used for the "bottom" (base) part of the hierarchy while
the polymorphism inheritance — for the "top" (derived) part.
For example:


#pragma db object
class person
{
...
};

#pragma db object polymorphic
class employee: public person // Reuse inheritance.
{
...
};

#pragma db object
class temporary_employee: public employee // Polymorphism inheritance.
{
...
};

#pragma db object
class permanent_employee: public employee // Polymorphism inheritance.
{
...
};






9 Views

An ODB view is a C++ class or struct type
that embodies a light-weight, read-only projection of one or more
persistent objects or database tables or the result of a native SQL
query execution.

Some of the common applications of views include loading a subset
of data members from objects or columns from database tables, executing
and handling results of arbitrary SQL queries, including aggregate
queries, as well as joining multiple objects and/or database tables
using object relationships or custom join conditions.

Many relational databases also define the concept of views. Note,
however, that ODB views are not mapped to database views. Rather,
by default, an ODB view is mapped to an SQL SELECT
query. However, if desired, it is easy to create an ODB view
that is based on a database view.

Usually, views are defined in terms of other persistent entities,
such as persistent objects, database tables, sequences, etc.
Therefore, before we can examine our first view, we need to
define a few persistent objects and a database table. We will
use this model in examples throughout this chapter. Here we
assume that you are familiar with ODB object relationship
support (Chapter 6, "Relationships").


#pragma db object
class country
{
...

#pragma db id
std::string code_; // ISO 2-letter country code.

std::string name_;
};

#pragma db object
class employer
{
...

#pragma db id
unsigned long id_;

std::string name_;
};

#pragma db object
class employee
{
...

#pragma db id
unsigned long id_;

std::string first_;
std::string last_;

unsigned short age_;

shared_ptr<country> residence_;
shared_ptr<country> nationality_;

shared_ptr<employer> employed_by_;
};


Besides these objects, we also have the legacy
employee_extra table that is not mapped to any persistent
class. It has the following definition:


CREATE TABLE employee_extra(
employee_id INTEGER NOT NULL,
vacation_days INTEGER NOT NULL,
previous_employer_id INTEGER)


The above persistent objects and database table as well as many of
the views shown in this chapter are based on the
view example which can be found in the
odb-examples package of the ODB distribution.

To declare a view we use the db view pragma,
for example:


#pragma db view object(employee)
struct employee_name
{
std::string first;
std::string last;
};


The above example shows one of the simplest views that we can create.
It has a single associated object (employee) and its
purpose is to extract the employee's first and last names without
loading any other data, such as the referenced country
and employer objects.

Views use the same query facility (Chapter 4, "Querying
the Database") as persistent objects. Because support for queries
is optional and views cannot be used without this support, you need
to compile any header that defines a view with the
--generate-query ODB compiler option.

To query the database for a view we use the database::query()
function in exactly the same way as we would use it to query the
database for an object. For example, the following code fragment
shows how we can find the names of all the employees that are
younger than 31:


typedef odb::query<employee_name> query;
typedef odb::result<employee_name> result;

transaction t (db.begin ());

result r (db.query<employee_name> (query::age < 31));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
const employee_name& en (*i);
cout << en.first << " " << en.last << endl;
}

t.commit ();


A view can be defined as a projection of one or more objects, one
or more tables, a combination of objects and tables, or it can be
the result of a custom SQL query. The following sections discuss each
of these kinds of view in more detail.

9.1 Object Views

To associate one or more objects with a view we use the
db object pragma (Section
12.2.1, "object"). We have already seen
a simple, single-object view in the introduction to this chapter.
To associate the second and subsequent objects we repeat the
db object pragma for each additional object,
for example:


#pragma db view object(employee) object(employer)
struct employee_employer
{
std::string first;
std::string last;
std::string name;
};


The complete syntax of the db object pragma is
shown below:

object(name
[= alias]
[: join-condition])

The name part is a potentially qualified persistent class
name that has been defined previously. The optional alias
part gives this object an alias. If provided, the alias is used
in several contexts instead of the object's unqualified name. We
will discuss aliases further as we cover each of these contexts
below. The optional join-condition part provides the
criteria which should be used to associate this object with any
of the previously associated objects or, as we will see in
Section 9.3, "Mixed Views", tables. Note that
while the first associated object can have an alias, it cannot
have a join condition.

For each subsequent associated object the ODB compiler needs
a join condition and there are several ways to specify
it. The easiest way is to omit it altogether and let the ODB
compiler try to come up with a join condition automatically.
To do this the ODB compiler will examine each previously
associated object for object relationships
(Chapter 6, "Relationships") that
may exist between these objects and the object being associated.
If such a relationship exists and is unambiguous, that is
there is only one such relationship, then the ODB compiler
will automatically use it to come up with the join condition for
this object. This is exactly what happens in the previous
example: there is a single relationship
(employee::employed_by) between the
employee and employer objects.

On the other hand, consider this view:


#pragma db view object(employee) object(country)
struct employee_residence
{
std::string first;
std::string last;
std::string name;
};


While there is a relationship between country and
employee, it is ambiguous. It can be
employee::residence_ (which is what we want) or
it can be employee::nationality_ (which we don't
want). As result, when compiling the above view, the ODB
compiler will issue an error indicating an ambiguous object
relationship. To resolve this ambiguity, we can explicitly
specify the object relationship that should be used to create
the join condition as the name of the corresponding data member.
Here is how we can fix the employee_residence
view:


#pragma db view object(employee) object(country: employee::residence_)
struct employee_residence
{
std::string first;
std::string last;
std::string name;
};


It is possible to associate the same object with a single view
more than once using different join conditions. However, in
this case, we have to use aliases to assign different names
for each association. For example:


#pragma db view object(employee) \
object(country = res_country: employee::residence_) \
object(country = nat_country: employee::nationality_)
struct employee_country
{
...
};


Note that correctly defining data members in this view requires
the use of a mechanism that we haven't yet covered. We will
see how to do this shortly.

If we assign an alias to an object and refer to a data member of
this object in one of the join conditions, we have to use the
unqualified alias name instead of the potentially qualified
object name. For example:


#pragma db view object(employee = ee) object(country: ee::residence_)
struct employee_residence
{
...
};


The last way to specify a join condition is to provide a custom
query expression. This method is primarily useful if you would
like to associate an object using a condition that does not
involve an object relationship. Consider, for example, a
modified employee object from the beginning of
the chapter with an added country of birth member. For one
reason or another we have decided not to use a relationship to
the country object, as we have done with
residence and nationality.


#pragma db object
class employee
{
...

std::string birth_place_; // Country name.
};


If we now want to create a view that returns the birth country code
for an employee, then we have to use a custom join condition when
associating the country object. For example:


#pragma db view object(employee) \
object(country: employee::birth_place_ == country::name_)
struct employee_birth_code
{
std::string first;
std::string last;
std::string code;
};


The syntax of the query expression in custom join conditions
is the same as in the query facility used to query the database
for objects (Chapter 4, "Querying the Database")
except that for query members, instead of using
odb::query<object>::member names, we refer directly
to object members.

Looking at the views we have defined so far, you may be wondering
how the ODB compiler knows which view data members correspond to which
object data members. While the names are similar, they are not exactly
the same, for example employee_name::first and
employee::first_.

As with join conditions, when it comes to associating data members,
the ODB compiler tries to do this automatically. It first searches
all the associated objects for an exact name match. If no match is
found, then the ODB compiler compares the so-called public names.
A public name of a member is obtained by removing the common member
name decorations, such as leading and trailing underscores, the
m_ prefix, etc. In both of these searches the ODB
compiler also makes sure that the types of the two members are the
same or compatible.

If one of the above searches returned a match and it is unambiguous, that
is there is only one match, then the ODB compiler will automatically
associate the two members. On the other hand, if no match is found
or the match is ambiguous, the ODB compiler will issue an error.
To associate two differently-named members or to resolve an ambiguity,
we can explicitly specify the member association using the
db column pragma (Section 12.4.9,
"column"). For example:


#pragma db view object(employee) object(employer)
struct employee_employer
{
std::string first;
std::string last;

#pragma db column(employer::name_)
std::string employer_name;
};


If an object data member specifies the SQL type with
the db type pragma (Section
12.4.3, "type"), then this type is also used for
the associated view data members.

Note also that similar to join conditions, if we assign an alias to
an object and refer to a data member of this object in one of the
db column pragmas, then we have to use the
unqualified alias name instead of the potentially qualified
object name. For example:


#pragma db view object(employee) \
object(country = res_country: employee::residence_) \
object(country = nat_country: employee::nationality_)
struct employee_country
{
std::string first;
std::string last;

#pragma db column(res_country::name_)
std::string res_country_name;

#pragma db column(nat_country::name_)
std::string nat_country_name;
};


Besides specifying just the object member, we can also specify a
+-expression in the db column pragma. A
+-expression consists of string literals and object
member references connected using the + operator.
It is primarily useful for defining aggregate views based on
SQL aggregate functions, for example:


#pragma db view object(employee)
struct employee_count
{
#pragma db column("count(" + employee::id_ + ")")
std::size_t count;
};


When querying the database for a view, we may want to provide
additional query criteria based on the objects associated with
this view. To support this a view defines query members for all
the associated objects which allows us to refer to such objects'
members using the odb::query<view>::member expressions.
This is similar to how we can refer to object members using the
odb::query<object>::member expressions when
querying the database for an object. For example:


typedef odb::result<employee_count> result;
typedef odb::query<employee_count> query;

transaction t (db.begin ());

// Find the number of employees with the Doe last name.
//
result r (db.query<employee_count> (query::last == "Doe"));

// Result of this aggregate query contains only one element.
//
cout << r.begin ()->count << endl;

t.commit ();


In the above query we used the last name data member from the associated
employee object to only count employees with the specific
name.

When a view has only one associated object, the query members
corresponding to this object are defined directly in the
odb::query<view> scope. For instance,
in the above example, we referred to the last name member as
odb::query<employee_count>::last. However, if
a view has multiple associated objects, then query members
corresponding to each such object are defined in a nested
scope named after the object. As an example, consider
the employee_employer view again:


#pragma db view object(employee) object(employer)
struct employee_employer
{
std::string first;
std::string last;

#pragma db column(employer::name_)
std::string employer_name;
};


Now, to refer to the last name data member from the employee
object we use the
odb::query<...>::employee::last expression.
Similarly, to refer to the employer name, we use the
odb::query<...>::employer::name expression.
For example:


typedef odb::result<employee_employer> result;
typedef odb::query<employee_employer> query;

transaction t (db.begin ());

result r (db.query<employee_employer> (
query::employee::last == "Doe" &&
query::employer::name == "Simple Tech Ltd"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
cout << i->first << " " << i->last << " " << i->employer_name << endl;

t.commit ();


If we assign an alias to an object, then this alias is used to
name the query members scope instead of the object name. As an
example, consider the employee_country view again:


#pragma db view object(employee) \
object(country = res_country: employee::residence_) \
object(country = nat_country: employee::nationality_)
struct employee_country
{
...
};


And a query which returns all the employees that have the same
country of residence and nationality:


typedef odb::query<employee_country> query;
typedef odb::result<employee_country> result;

transaction t (db.begin ());

result r (db.query<employee_country> (
query::res_country::name == query::nat_country::name));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
cout << i->first << " " << i->last << " " << i->res_country_name << endl;

t.commit ();


Note also that unlike object query members, view query members do
no support referencing members in related objects. For example,
the following query is invalid:


typedef odb::query<employee_name> query;
typedef odb::result<employee_name> result;

transaction t (db.begin ());

result r (db.query<employee_name> (
query::employed_by->name == "Simple Tech Ltd"));

t.commit ();


To get this behavior, we would instead need to associate the
employer object with this view and then use the
query::employer::name expression instead of
query::employed_by->name.

As we have discussed above, if specified, an object alias is
used instead of the object name in the join condition, data
member references in the db column pragma,
as well as to name the query members scope. The object alias
is also used as a table name alias in the underlying
SELECT statement generated by the ODB compiler.
Normally, you would not use the table alias directly with
object views. However, if for some reason you need to refer
to a table column directly, for example, as part of a native
query expression, and you need to qualify the column with
the table, then you will need to use the table alias instead.

9.2 Table Views

A table view is similar to an object view except that it is
based on one or more database tables instead of persistent
objects. Table views are primarily useful when dealing with
ad-hoc tables that are not mapped to persistent classes.

To associate one or more tables with a view we use the
db table pragma (Section 12.2.2,
"table"). To associate the second and subsequent
tables we repeat the db table pragma for each
additional table. For example, the following view is based on the
employee_extra legacy table we have defined at the
beginning of the chapter.


#pragma db view table("employee_extra")
struct employee_vacation
{
#pragma db column("employee_id") type("INTEGER")
unsigned long employee_id;

#pragma db column("vacation_days") type("INTEGER")
unsigned short vacation_days;
};


Besides the table name in the db table pragma
we also have to specify the column name for each view data
member. Note that unlike for object views, the ODB compiler
does not try to automatically come up with column names for
table views. Furthermore, we cannot use references to object
members either, since there are no associated objects in table
views. Instead, the actual column name or column expression
must be specified as a string literal. The column name can
also be qualified with a table name either in the
"table.column" form or, if either a table
or a column name contains a period, in the
"table"."column" form. The following example
illustrates the use of a column expression:


#pragma db view table("employee_extra")
struct employee_max_vacation
{
#pragma db column("max(vacation_days)") type("INTEGER")
unsigned short max_vacation_days;
};


Both the asociated table names and the column names can be qualified
with a database schema, for example:


#pragma db view table("hr.employee_extra")
struct employee_max_vacation
{
#pragma db column("hr.employee_extra.vacation_days") type("INTEGER")
unsigned short vacation_days;
};


For more information on database schemas and the format of the
qualified names, refer to Section 12.1.8,
"schema".

Note also that in the above examples we specified the SQL type
for each of the columns to make sure that the ODB compiler
has knowledge of the actual types as specified in the database
schema. This is required to obtain correct and optimal
generated code.


The complete syntax of the db table pragma
is similar to the db object pragma and is shown
below:

table("name"
[= "alias"]
[: join-condition])

The name part is a database table name. The optional
alias part gives this table an alias. If provided, the
alias must be used instead of the table whenever a reference
to a table is used. Contexts where such a reference may
be needed include the join condition (discussed below),
column names, and query expressions. The optional join-condition
part provides the criteria which should be used to associate this
table with any of the previously associated tables or, as we will see in
Section 9.3, "Mixed Views", objects. Note that
while the first associated table can have an alias, it cannot have
a join condition.

Similar to object views, for each subsequent associated table the
ODB compiler needs a join condition. However, unlike for object views,
for table views the ODB compiler does not try to come up with one
automatically. Furthermore, we cannot use references to object
members corresponding to object relationships either, since there
are no associated objects in table views. Instead, for each
subsequent associated table, a join condition must be
specified as a custom query expression. While the syntax of the
query expression is the same as in the query facility used to query
the database for objects (Chapter 4, "Querying the
Database"), a join condition for a table is normally specified
as a single string literal containing a native SQL query expression.

As an example of a multi-table view, consider the
employee_health table that we define in addition
to employee_extra:


CREATE TABLE employee_health(
employee_id INTEGER NOT NULL,
sick_leave_days INTEGER NOT NULL)


Given these two tables we can now define a view that returns both
the vacation and sick leave information for each employee:


#pragma db view table("employee_extra" = "extra") \
table("employee_health" = "health": \
"extra.employee_id = health.employee_id")
struct employee_leave
{
#pragma db column("extra.employee_id") type("INTEGER")
unsigned long employee_id;

#pragma db column("vacation_days") type("INTEGER")
unsigned short vacation_days;

#pragma db column("sick_leave_days") type("INTEGER")
unsigned short sick_leave_days;
};


Querying the database for a table view is the same as for an
object view except that we can only use native query expressions.
For example:


typedef odb::query<employee_leave> query;
typedef odb::result<employee_leave> result;

transaction t (db.begin ());

unsigned short v_min = ...
unsigned short l_min = ...

result r (db.query<employee_leave> (
"vacation_days > " + query::_val(v_min) + "AND"
"sick_leave_days > " + query::_val(l_min)));

t.commit ();



9.3 Mixed Views

A mixed view has both associated objects and tables. As a first
example of a mixed view, let us improve employee_vacation
from the previous section to return the employee's first
and last names instead of the employee id. To achieve this we
have to associate both the employee object and
the employee_extra table with the view:


#pragma db view object(employee) \
table("employee_extra" = "extra": "extra.employee_id = " + employee::id_)
struct employee_vacation
{
std::string first;
std::string last;

#pragma db column("extra.vacation_days") type("INTEGER")
unsigned short vacation_days;
};


When querying the database for a mixed view, we can use query members
for the parts of the query expression that involves object members
but have to fall back to using the native syntax for the parts that
involve table columns. For example:


typedef odb::query<employee_vacation> query;
typedef odb::result<employee_vacation> result;

transaction t (db.begin ());

result r (db.query<employee_vacation> (
(query::last == "Doe") + "AND extra.vacation_days <> 0"));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
cout << i->first << " " << i->last << " " << i->vacation_days << endl;

t.commit ();


As another example, consider a more advanced view that associates
two objects via a legacy table. This view allows us to find the
previous employer name for each employee:


#pragma db view object(employee) \
table("employee_extra" = "extra": "extra.employee_id = " + employee::id_) \
object(employer: "extra.previous_employer_id = " + employer::id_)
struct employee_prev_employer
{
std::string first;
std::string last;

// If previous_employer_id is NULL, then the name will be NULL as well.
// We use the odb::nullable wrapper to handle this.
//
#pragma db column(employer::name_)
odb::nullable<std::string> prev_employer_name;
};


9.4 View Query Conditions

Object, table, and mixed views can also specify an optional query
condition that should be used whenever the database is queried for
this view. To specify a query condition we use the
db query pragma (Section 12.2.3,
"query").

As an example, consider a view that returns some information about
all the employees that are over a predefined retirement age.
One way to implement this would be to define a standard object
view as we have done in the previous sections and then use a
query like this:


result r (db.query<employee_retirement> (query::age > 50));


The problem with the above approach is that we have to keep
repeating the query::age > 50 expression every
time we execute the query, even though this expression always
stays the same. View query conditions allow us to solve this
problem. For example:


#pragma db view object(employee) query(employee::age > 50)
struct employee_retirement
{
std::string first;
std::string last;
unsigned short age;
};


With this improvement we can rewrite our query like this:


result r (db.query<employee_retirement> ());


But what if we may also need to restrict the result set based on
some varying criteria, such as the employee's last name? Or, in other
words, we may need to combine a constant query expression specified
in the db query pragma with the varying expression
specified at the query execution time. To allow this, the
db query pragma syntax supports the use of the special
(?) placeholder that indicates the position in the
constant query expression where the runtime expression should be
inserted. For example:


#pragma db view object(employee) query(employee::age > 50 && (?))
struct employee_retirement
{
std::string first;
std::string last;
unsigned short name;
};


With this change we can now use additional query criteria in our
view:


result r (db.query<employee_retirement> (query::last == "Doe"));


The syntax of the expression in a query condition is the same as in
the query facility used to query the database for objects
(Chapter 4, "Querying the Database") except for
two differences. Firstly, for query members, instead of
using odb::query<object>::member names, we refer
directly to object members, using the object alias instead of the
object name if an alias was assigned. Secondly, query conditions
support the special (?) placeholder which can be used
both in the C++-integrated query expressions as was shown above
and in native SQL expressions specified as string literals. The
following view is an example of the latter case:


#pragma db view table("employee_extra") \
query("vacation_days <> 0 AND (?)")
struct employee_vacation
{
...
};


Another common use case for query conditions are views with the
ORDER BY or GROUP BY clause. Such
clauses are normally present in the same form in every query
involving such views. As an example, consider an aggregate
view which calculate the minimum and maximum ages of employees
for each employer:


#pragma db view object(employee) object(employer) \
query ((?) + "GROUP BY" + employer::name_)
struct employer_age
{
#pragma db column(employer::name_)
std::string employer_name;

#pragma db column("min(" + employee::age_ + ")")
unsigned short min_age;

#pragma db column("max(" + employee::age_ + ")")
unsigned short max_age;
};


9.5 Native Views

The last kind of view supported by ODB is a native view. Native
views are a low-level mechanism for capturing results of native
SQL queries. Native views don't have associated tables or objects.
Instead, we use the db query pragma to specify
the native SQL query, which must at a minimum include the
select-list and, if applicable, the from-list. For example, here
is how we can re-implement the employee_vacation table
view from Section 9.2 above as a native view:


#pragma db view query("SELECT employee_id, vacation_days " \
"FROM employee_extra")
struct employee_vacation
{
#pragma db type("INTEGER")
unsigned long employee_id;

#pragma db type("INTEGER")
unsigned short vacation_days;
};


In native views the columns in the query select-list are
associated with the view data members in the order specified.
That is, the first column is stored in the first member, the
second column — in the second member, and so on. The ODB compiler
does not perform any error checking in this association. As a result
you must make sure that the number and order of columns in the
query select-list match the number and order of data members
in the view. This is also the reason why we are not
required to provide the column name for each data member in native
views, as is the case for object and table views.

Note also that while it is always possible to implement a table
view as a native view, the table views must be preferred since
they are safer. In a native view, if you add, remove, or
rearrange data members without updating the column list in the
query, or vice versa, at best, this will result in a runtime
error. In contrast, in a table view such changes will result
in the query being automatically updated.

Similar to object and table views, the query specified for
a native view can contain the special (?)
placeholder which is replaced with the query expression
specified at the query execution time.
If the native query does not contain a placeholder, as in
the example above, then any query expression specified at
the query execution time is appended to the query text
along with the WHERE keyword, if required.
The following example shows the usage of the placeholder:


#pragma db view query("SELECT employee_id, vacation_days " \
"FROM employee_extra " \
"WHERE vacation_days <> 0 AND (?)")
struct employee_vacation
{
...
};


As another example, consider a view that returns the next
value of a database sequence:


#pragma db view query("SELECT nextval('my_seq')")
struct sequence_value
{
unsigned long long value;
};


While this implementation can be acceptable in some cases, it has
a number of drawbacks. Firstly, the name of the sequence is
fixed in the view, which means if we have a second sequence, we
will have to define another, almost identical view. Similarly,
the operation that we perform on the sequence is also fixed.
In some situations, instead of returning the next value, we may
need the last value.

Note that we cannot use the placeholder mechanism to resolve
these problems since placeholders can only be used in the
WHERE, GROUP BY, and similar
clauses. In other words, the following won't work:


#pragma db view query("SELECT nextval('(?)')")
struct sequence_value
{
unsigned long long value;
};

result r (db.query<sequence_value> ("my_seq"));


To support these kinds of use cases, ODB allows us to specify the
complete query for a native view at runtime rather than at the view
definition. To indicate that a native view has a runtime query,
we can either specify the empty db query
pragma or omit the pragma altogether. For example:


#pragma db view
struct sequence_value
{
unsigned long long value;
};


Given this view, we can perform the following queries:


typedef odb::query<sequence_value> query;
typedef odb::result<sequence_value> result;

string seq_name = ...

result l (db.query<sequence_value> (
"SELECT lastval('" + seq_name + "')"));

result n (db.query<sequence_value> (
"SELECT nextval('" + seq_name + "')"));



9.6 Other View Features and Limitations

Views cannot be derived from other views. However, you can derive
a view from a transient C++ class. View data members cannot be
object pointers. If you need to access data from a pointed-to
object, then you will need to associate such an object with
the view. Similarly, view data members cannot be containers.
These two limitations also apply to composite value types that
contain object pointers or containers. Such composite values
cannot be used as view data members.

On the other hand, composite values that do not contain object
pointers or containers can be used in views. As an example,
consider a modified version of the employee persistent
class that stores a person's name as a composite value:


#pragma db value
class person_name
{
std::string first_;
std::string last_;
};

#pragma db object
class employee
{
...

person_name name_;

...
};


Given this change, we can re-implement the employee_name
view like this:


#pragma db view object(employee)
struct employee_name
{
person_name name;
};


It is also possible to extract some or all of the nested members
of a composite value into individual view data members. Here is
how we could have defined the employee_name view
if we wanted to keep its original structure:


#pragma db view object(employee)
struct employee_name
{
#pragma db column(employee::name.first_)
std::string first;

#pragma db column(employee::name.last_)
std::string last;
};







10 Session

A session is an application's unit of work that may encompass several
database transactions. In this version of ODB a session is just an
object cache. In future versions it may provide additional
functionality, such as delayed database operations and automatic
object state change tracking. As discussed later in
Section 10.2, "Custom Sessions", it is also
possible to provide a custom session implementation that provides
these or other features.

Session support is optional and can be enabled or disabled on the
per object basis using the db session pragma, for
example:


#pragma db object session
class person
{
...
};


We can also enable or disable session support for a group of
objects at the namespace level:


#pragma db namespace session
namespace accounting
{
#pragma db object // Session support is enabled.
class employee
{
...
};

#pragma db object session(false) // Session support is disabled.
class employer
{
...
};
}


Finally, we can pass the --generate-session ODB compiler
option to enable session support by default. With this option session
support will be enabled for all the persistent classes except those
for which it was explicitly disabled using the
db session. An alternative to this method with the
same effect is to enable session support for the global namespace:


#pragma db namespace() session


Each thread of execution in an application can have only one active
session at a time. A session is started by creating an instance of
the odb::session class and is automatically terminated
when this instance is destroyed. You will need to include the
<odb/session.hxx> header file to make this class
available in your application. For example:


#include <odb/database.hxx>
#include <odb/session.hxx>
#include <odb/transaction.hxx>

using namespace odb::core;

{
session s;

// First transaction.
//
{
transaction t (db.begin ());
...
t.commit ();
}

// Second transaction.
//
{
transaction t (db.begin ());
...
t.commit ();
}

// Session 's' is terminated here.
}


The session class has the following interface:


namespace odb
{
class session
{
public:
session (bool make_current = true);
~session ();

// Copying or assignment of sessions is not supported.
//
private:
session (const session&);
session& operator= (const session&);

// Current session interface.
//
public:
static session&
current ();

static bool
has_current ();

static void
current (session&);

static void
reset_current ();

static session*
current_pointer ();

static void
current_pointer (session*);

// Object cache interface.
//
public:
template <typename T>
struct cache_position {...};

template <typename T>
cache_position<T>
cache_insert (database&,
const object_traits<T>::id_type&,
const object_traits<T>::pointer_type&);

template <typename T>
object_traits<T>::pointer_type
cache_find (database&, const object_traits<T>::id_type&) const;

template <typename T>
void
cache_erase (const cache_position<T>&);

template <typename T>
void
cache_erase (database&, const object_traits<T>::id_type&);
};
}


The session constructor creates a new session and, if the
make_current argument is true, sets it as a
current session for this thread. If we try to make a session current
while there is already another session in effect for this thread,
then the constructor throws the odb::already_in_session
exception. The destructor clears the current session for this
thread if this session is the current one.

The static current() accessor returns the currently active
session for this thread. If there is no active session, this function
throws the odb::not_in_session exception. We can check
whether there is a session in effect in this thread using the
has_current() static function.

The static current() modifier allows us to set the
current session for this thread. The reset_current()
static function clears the current session. These two functions
allow for more advanced use cases, such as multiplexing
two or more sessions on the same thread.

The static current_pointer() overloaded functions
provided the same functionality but using pointers. Specifically,
the current_pointer() accessor can be used to
test whether there is a current session and get a pointer to it
all with a single call.

We normally don't use the object cache interface directly. However,
it could be useful in some cases, for example, to find out whether
an object has already been loaded. Note that when calling
cache_insert(), cache_find(), or
the second version of cache_erase(), you need to
specify the template argument (object type) explicitly. It is
also possible to access the underlying cache data structures
directly. This can be useful if, for example, you want to
iterate over the objects store in the cache. Refer to the ODB
runtime header files for more details on this direct access.

10.1 Object Cache

A session is an object cache. Every time a session-enabled object is
made persistent by calling the database::persist() function
(Section 3.8, "Making Objects Persistent"), loaded
by calling the database::load() or database::find()
function (Section 3.9, "Loading Persistent Objects"),
or loaded by iterating over a query result (Section 4.4,
"Query Result"), the pointer to the persistent object, in the form
of the canonical object pointer (Section 3.3, "Object
and View Pointers"), is stored in the session. For as long as the
session is in effect, any subsequent calls to load the same object will
return the cached instance. When an object's state is deleted from the
database with the database::erase() function
(Section 3.11, "Deleting Persistent Objects"), the
cached object pointer is removed from the session. For example:


shared_ptr<person> p (new person ("John", "Doe"));

session s;
transaction t (db.begin ());

unsigned long id (db.persist (p)); // p is cached in s.
shared_ptr<person> p1 (db.load<person> (id)); // p1 same as p.

t.commit ();



The per-object caching policies depend on the object pointer kind
(Section 6.5, "Using Custom Smart Pointers").
Objects with a unique pointer, such as std::auto_ptr
or std::unique_ptr, as an object pointer are never
cached since it is not possible to have two such pointers pointing
to the same object. When an object is persisted via a pointer or
loaded as a dynamically allocated instance, objects with both raw
and shared pointers as object pointers are cached. If an object is
persisted as a reference or loaded into a pre-allocated instance,
the object is only cached if its object pointer is a raw pointer.

Also note that when we persist an object as a constant reference
or constant pointer, the session caches such an object as
unrestricted (non-const). This can lead to undefined
behavior if the object being persisted was actually created as
const and is later found in the session cache and
used as non-const. As a result, when using sessions,
it is recommended that all persistent objects be created as
non-const instances. The following code fragment
illustrates this point:


void save (database& db, shared_ptr<const person> p)
{
transaction t (db.begin ());
db.persist (p); // Persisted as const pointer.
t.commit ();
}

session s;

shared_ptr<const person> p1 (new const person ("John", "Doe"));
unsigned long id1 (save (db, p1)); // p1 is cached in s as non-const.

{
transaction t (db.begin ());
shared_ptr<person> p (db.load<person> (id1)); // p == p1
p->age (30); // Undefined behavior since p1 was created const.
t.commit ();
}

shared_ptr<const person> p2 (new person ("Jane", "Doe"));
unsigned long id2 (save (db, p2)); // p2 is cached in s as non-const.

{
transaction t (db.begin ());
shared_ptr<person> p (db.load<person> (id2)); // p == p2
p->age (30); // Ok, since p2 was not created const.
t.commit ();
}


10.2 Custom Sessions

ODB can use a custom session implementation instead of the
default odb::session. There could be multiple
reasons for an application to provide its own session. For
example, the application may already include a notion of an
object cache or registry which ODB can re-use. A custom
session can also provide additional functionality, such as
automatic change tracking, delayed database operations, or
object eviction. Finally, the session-per-thread approach used
by odb::session may not be suitable for all
applications. For instance, some may need a thread-safe
session that can be shared among multiple threads. For
an example of a custom session that implements automatic
change tracking by keeping original copies of the objects,
refer to the common/session/custom test
in the odb-tests package.

To use a custom session we need to specify its type with
the --session-type ODB compiler command line
option. We also need to include its definition into the
generated header file. This can be achieved with the
--hxx-prologue option. For example, if our
custom session is called app::session and
is defined in the app/session.hxx header
file, then the corresponding ODB compiler options would
look like this:


odb --hxx-prologue "#include \"app/session.hxx\"" \
--session-type ::app::session ...


A custom session should provide the following interface:


class custom_session
{
public:
template <typename T>
struct cache_position
{
...
};

// Cache management functions.
//
template <typename T>
static cache_position<T>
_cache_insert (odb::database&,
const typename odb::object_traits<T>::id_type&,
const typename odb::object_traits<T>::pointer_type&);

template <typename T>
static typename odb::object_traits<T>::pointer_type
_cache_find (odb::database&,
const typename odb::object_traits<T>::id_type&);

template <typename T>
static void
_cache_erase (const cache_position<T>&);

// Notification functions.
//
template <typename T>
static void
_cache_persist (const cache_position<T>&);

template <typename T>
static void
_cache_load (const cache_position<T>&);

template <typename T>
static void
_cache_update (odb::database&, const T& obj);

template <typename T>
static void
_cache_erase (odb::database&,
const typename odb::object_traits<T>::id_type&);
};


The cache_position class template represent a position
in the cache of the inserted object. It should be default and
copy-constructible as well as copy-assignable. The default
constructor shall create a special empty/NULL
position. A call of any of the cache management or notification
functions with such an empty/NULL position shall be
ignored.

The _cache_insert() function shall add the object into
the object cache and return its position. The _cache_find()
function looks an object up in the object cache given its id.
It returns a NULL pointer if the object is not
found. The _cache_erase() cache management function
shall remove the object from the cache. It is called
if the database operation that caused the object to be inserted
(for example, load) failed. Note also that after insertion the object
state is undefined. You can only access the object state
(for example, make a copy or clear a flag) from one of the
notification functions discussed below.

The notification functions are called after an object has
been persisted, loaded, updated, or erased, respectively. If
your session implementation does not need some of the
notifications, you still have to provide their functions,
however, you can leave their implementations empty.

Notice also that all the cache management and notification
functions are static. This is done in order to allow for a
custom notion of a current session. Normally, the first
step a non-empty implementation will perform is lookup the
current session.






11 Optimistic Concurrency

The ODB transaction model (Section 3.5,
"Transactions") guarantees consistency as long as we perform all the
database operations corresponding to a specific application transaction
in a single database transaction. That is, if we load an object within a
database transaction and update it in the same transaction, then we are
guaranteed that the object state that we are updating in the database is
exactly the same as the state we have loaded. In other words, it is
impossible for another process or thread to modify the object state
in the database between these load and update operations.

In this chapter we use the term application transaction
to refer to a set of operations on persistent objects that an
application needs to perform in order to implement some
application-specific functionality. The term database
transaction refers to the set of database operations
performed between the ODB begin() and commit()
calls. Up until now we have treated application transactions and
database transactions as essentially the same thing.

While this model is easy to understand and straightforward to use,
it may not be suitable for applications that have long application
transactions. The canonical example of such a situation is an
application transaction that requires user input between loading
an object and updating it. Such an operation may take an arbitrary
long time to complete and performing it within a single database
transaction will consume database resources as well as prevent
other processes/threads from updating the object for too long.

The solution to this problem is to break up the long-lived
application transaction into several short-lived database
transactions. In our example that would mean loading the object
in one database transaction, waiting for user input, and then
updating the object in another database transaction. For example:


unsigned long id = ...;
person p;

{
transaction t (db.begin ());
db.load (id, p);
t.commit ();
}

cerr << "enter age for " << p.first () << " " << p.last () << endl;
unsigned short age;
cin >> age;
p.age (age);

{
transaction t (db.begin ());
db.update (p);
t.commit ();
}


This approach works well if we only have one process/thread that can ever
update the object. However, if we have multiple processes/threads
modifying the same object, then this approach does not guarantee
consistency anymore. Consider what happens in the above example if
another process updates the person's last name while we are waiting for
the user input. Since we loaded the object before this change occured,
our version of the person's data will still have the old name. Once we
receive the input from the user, we go ahead and update the object,
overwriting both the old age with the new one (correct) and the new name
with the old one (incorrect).

While there is no way to restore the consistency guarantee in
an application transaction that consists of multiple database
transactions, ODB provides a mechanism, called optimistic
concurrency, that allows applications to detect and potentially
recover from such inconsistencies.

In essence, the optimistic concurrency model detects mismatches
between the current object state in the database and the state
when it was loaded into the application memory. Such a mismatch
would mean that the object was changed by another process or
thread. There are several ways to implement such state mismatch
detection. Currently, ODB uses object versioning while other
methods, such as timestamps, may be supported in the future.

To declare a persistent class with the optimistic concurrency model we
use the optimistic pragma (Section 12.1.5,
"optimistic"). We also use the version
pragma (Section 12.4.15, "version")
to specify which data member will store the object version. For
example:


#pragma db object optimistic
class person
{
...

#pragma db version
unsigned long version_;
};


The version data member is managed by ODB. It is initialized to
1 when the object is made persistent and incremented
by 1 with each update. The 0 version value
is not used by ODB and the application can use it as a special value,
for example, to indicate that the object is transient. Note that
for optimistic concurrency to function properly, the application
should not modify the version member after making the object persistent
or loading it from the database and until deleting the state of this
object from the database. To avoid any accidental modifications
to the version member, we can declare it const, for
example:


#pragma db object optimistic
class person
{
...

#pragma db version
const unsigned long version_;
};


When we call the database::update() function
(Section 3.10, "Updating Persistent Objects") and pass
an object that has an outdated state, the odb::object_changed
exception is thrown. At this point the application has two
recovery options: it can abort and potentially restart the
application transaction or it can reload the new object
state from the database, re-apply or merge the changes, and call
update() again. Note that aborting an application
transaction that performs updates in multiple database transactions
may require reverting changes that have already been committed to
the database. As a result, this strategy works best if all the
updates are performed in the last database transaction of the
application transaction. This way the changes can be reverted
by simply rolling back this last database transaction.

The following example shows how we can reimplement the above
transaction using the second recovery option:


unsigned long id = ...;
person p;

{
transaction t (db.begin ());
db.load (id, p);
t.commit ();
}

cerr << "enter age for " << p.first () << " " << p.last () << endl;
unsigned short age;
cin >> age;
p.age (age);

{
transaction t (db.begin ());

try
{
db.update (p);
}
catch (const object_changed&)
{
db.reload (p);
p.age (age);
db.update (p);
}

t.commit ();
}


An important point to note in the above code fragment is that the second
update() call cannot throw the object_changed
exception because we are reloading the state of the object
and updating it within the same database transaction.

Depending on the recovery strategy employed by the application,
an application transaction with a failed update can be significantly
more expensive than a successful one. As a result, optimistic
concurrency works best for situations with low to medium contention
levels where the majority of the application transactions complete
without update conflicts. This is also the reason why this concurrency
model is called optimistic.

In addition to updates, ODB also performs state mismatch detection
when we are deleting an object from the database
(Section 3.11, "Deleting Persistent Objects").
To understand why this can be important, consider the following
application transaction:


unsigned long id = ...;
person p;

{
transaction t (db.begin ());
db.load (id, p);
t.commit ();
}

string answer;
cerr << "age is " << p.age () << ", delete?" << endl;
getline (cin, answer);

if (answer == "yes")
{
transaction t (db.begin ());
db.erase (p);
t.commit ();
}


Consider again what happens if another process or thread updates
the object by changing the person's age while we are waiting for
the user input. In this case, the user makes the decision based on
a certain age while we may delete (or not delete) an object that has
a completely different age. Here is how we can fix this problem
using optimistic concurrency:


unsigned long id = ...;
person p;

{
transaction t (db.begin ());
db.load (id, p);
t.commit ();
}

string answer;
for (bool done (false); !done; )
{
if (answer.empty ())
cerr << "age is " << p.age () << ", delete?" << endl;
else
cerr << "age changed to " << p.age () << ", still delete?" << endl;

getline (cin, answer);

if (answer == "yes")
{
transaction t (db.begin ());

try
{
db.erase (p);
done = true;
}
catch (const object_changed&)
{
db.reload (p);
}

t.commit ();
}
else
done = true;
}


Note that state mismatch detection is performed only if we delete
an object by passing the object instance to the erase()
function. If we want to delete an object with the optimistic concurrency
model regardless of its state, then we need to use the erase()
function that deletes an object given its id, for example:


{
transaction t (db.begin ());
db.erase (p.id ());
t.commit ();
}


Finally, note that for persistent classes with the optimistic concurrency
model both the update() function as well as the
erase() function that accepts an object instance as its
argument no longer throw the object_not_persistent
exception if there is no such object in the database. Instead,
this condition is treated as a change of object state and the
object_changed exception is thrown instead.

For complete sample code that shows how to use optimistic
concurrency, refer to the optimistic example in
the odb-examples package.






12 ODB Pragma Language

As we have already seen in previous chapters, ODB uses a pragma-based
language to capture database-specific information about C++ types.
This chapter describes the ODB pragma language in more detail. It
can be read together with other chapters in the manual to get a
sense of what kind of configurations and mapping fine-tuning are
possible. You can also use this chapter as a reference at a later
stage.

An ODB pragma has the following syntax:

#pragma db qualifier [specifier specifier ...]

The qualifier tells the ODB compiler what kind of C++ construct
this pragma describes. Valid qualifiers are object,
view, value, member,
namespace, index, and map.
A pragma with the object qualifier describes a persistent
object type. It tells the ODB compiler that the C++ class it describes
is a persistent class. Similarly, pragmas with the view
qualifier describe view types, the value qualifier
describes value types and the member qualifier is used
to describe data members of persistent object, view, and value types.
The namespace qualifier is used to describe common
properties of objects, views, and value types that belong to
a C++ namespace. The index qualifier defines a
database index. And, finally, the map qualifier
describes a mapping between additional database types and types
for which ODB provides built-in support.

The specifier informs the ODB compiler about a particular
database-related property of the C++ declaration. For example, the
id member specifier tells the ODB compiler that this
member contains this object's identifier. Below is the declaration
of the person class that shows how we can use ODB
pragmas:


#pragma db object
class person
{
...
private:
#pragma db member id
unsigned long id_;
...
};


In the above example we don't explicitly specify which C++ class or
data member the pragma belongs to. Rather, the pragma applies to
a C++ declaration that immediately follows the pragma. Such pragmas
are called positioned pragmas. In positioned pragmas that
apply to data members, the member qualifier can be
omitted for brevity, for example:


#pragma db id
unsigned long id_;


Note also that if the C++ declaration immediately following a
position pragma is incompatible with the pragma qualifier, an
error will be issued. For example:


#pragma db object // Error: expected class instead of data member.
unsigned long id_;


While keeping the C++ declarations and database declarations close
together eases maintenance and increases readability, we can also
place them in different parts of the same header file or even
factor them to a separate file. To achieve this we use the so called
named pragmas. Unlike positioned pragmas, named pragmas
explicitly specify the C++ declaration to which they apply by
adding the declaration name after the pragma qualifier. For example:


class person
{
...
private:
unsigned long id_;
...
};

#pragma db object(person)
#pragma db member(person::id_) id


Note that in the named pragmas for data members the member
qualifier is no longer optional. The C++ declaration name in the
named pragmas is resolved using the standard C++ name resolution
rules, for example:


namespace db
{
class person
{
...
private:
unsigned long id_;
...
};
}

namespace db
{
#pragma db object(person) // Resolves db::person.
}

#pragma db member(db::person::id_) id


As another example, the following code fragment shows how to use the
named value type pragma to map a C++ type to a native database type:


#pragma db value(bool) type("INT")

#pragma db object
class person
{
...
private:
bool married_; // Mapped to INT NOT NULL database type.
...
};


If we would like to factor the ODB pragmas into a separate file,
we can include this file into the original header file (the one
that defines the persistent types) using the #include
directive, for example:


// person.hxx

class person
{
...
};

#ifdef ODB_COMPILER
# include "person-pragmas.hxx"
#endif


Alternatively, instead of using the #include directive,
we can use the --odb-epilogue option to make the pragmas
known to the ODB compiler when compiling the original header file,
for example:


--odb-epilogue '#include "person-pragmas.hxx"'


The following sections cover the specifiers applicable to all the
qualifiers mentioned above.

The C++ header file that defines our persistent classes and
normally contains one or more ODB pragmas is compiled by both
the ODB compiler to generate the database support code and
the C++ compiler to build the application. Some C++ compilers
issue warnings about pragmas that they do not recognize. There
are several ways to deal with this problem which are covered
at the end of this chapter in Section 12.8,
"C++ Compiler Warnings".

12.1 Object Type Pragmas

A pragma with the object qualifier declares a C++ class
as a persistent object type. The qualifier can be optionally followed,
in any order, by one or more specifiers summarized in the table below:




Specifier
Summary
Section



table
table name for a persistent class
12.1.1



pointer
pointer type for a persistent class
12.1.2



abstract
persistent class is abstract
12.1.3



readonly
persistent class is read-only
12.1.4



optimistic
persistent class with the optimistic concurrency model
12.1.5



no_id
persistent class has no object id
12.1.6



callback
database operations callback
12.1.7



schema
database schema for a persistent class
12.1.8



polymorphic
persistent class is polymorphic
12.1.9



session
enable/disable session support for a persistent class
12.1.10



definition
definition location for a persistent class
12.1.11



transient
all non-virtual data members in a persistent class are transient
12.1.12




12.1.1 table

The table specifier specifies the table name that should
be used to store objects of the persistent class in a relational
database. For example:


#pragma db object table("people")
class person
{
...
};


If the table name is not specified, the class name is used as the
table name. The table name can be qualified with a database
schema, for example:


#pragma db object table("census.people")
class person
{
...
};


For more information on database schemas and the format of the
qualified names, refer to Section 12.1.8,
"schema".

12.1.2 pointer

The pointer specifier specifies the object pointer type
for the persistent class. The object pointer type is used to return,
pass, and cache dynamically allocated instances of a persistent
class. For example:


#pragma db object pointer(std::tr1::shared_ptr<person>)
class person
{
...
};


There are several ways to specify an object pointer with the
pointer specifier. We can use a complete pointer
type as shown in the example above. Alternatively, we can
specify only the template name of a smart pointer in which
case the ODB compiler will automatically append the class
name as a template argument. The following example is therefore
equivalent to the one above:


#pragma db object pointer(std::tr1::shared_ptr)
class person
{
...
};


If you would like to use the raw pointer as an object pointer,
you can use * as a shortcut:


#pragma db object pointer(*) // Same as pointer(person*)
class person
{
...
};


If a pointer type is not explicitly specified, the default pointer,
specified at the namespace level (Section 12.5.1,
"pointer") or with the --default-pointer
ODB compiler option, is used. If neither of these two mechanisms is
used to specify the pointer, then the raw pointer is used by default.

For a more detailed discussion of object pointers, refer to
Section 3.3, "Object and View Pointers".

12.1.3 abstract

The abstract specifier specifies that the persistent class
is abstract. An instance of an abstract class cannot be stored in
the database and is normally used as a base for other persistent
classes. For example:


#pragma db object abstract
class person
{
...
};

#pragma db object
class employee: public person
{
...
};

#pragma db object
class contractor: public person
{
...
};


Persistent classes with pure virtual functions are automatically
treated as abstract by the ODB compiler. For a more detailed
discussion of persistent class inheritance, refer to
Chapter 8, "Inheritance".

12.1.4 readonly

The readonly specifier specifies that the persistent class
is read-only. The database state of read-only objects cannot be
updated. In particular, this means that you cannot call the
database::update() function (Section 3.10,
"Updating Persistent Objects") for such objects. For example:


#pragma db object readonly
class person
{
...
};


Read-only and read-write objects can derive from each other without
any restrictions. When a read-only object derives from a read-write
object, the resulting whole object is read-only, including the part
corresponding to the read-write base. On the other hand, when a
read-write object derives from a read-only object, all the data
members that correspond to the read-only base are treated as
read-only while the rest is treated as read-write.

Note that it is also possible to declare individual data members
(Section 12.4.12, "readonly")
as well as composite value types (Section 12.3.6,
"readonly") as read-only.

12.1.5 optimistic

The optimistic specifier specifies that the persistent class
has the optimistic concurrency model. A class with the optimistic
concurrency model must also specify the data member that is used to
store the object version using the version pragma
(Section 12.4.15, "version").
For example:


#pragma db object optimistic
class person
{
...

#pragma db version
unsigned long version_;
};


If a base class has the optimistic concurrency model, then all its derived
classes will automatically have the optimistic concurrency model. The
current implementation also requires that in any given inheritance
hierarchy the object id and the version data members reside in the
same class.

For a more detailed discussion of optimistic concurrency, refer to
Chapter 11, "Optimistic Concurrency".

12.1.6 no_id

The no_id specifier specifies that the persistent class
has no object id. For example:


#pragma db object no_id
class person
{
...
};


A persistent class without an object id has limited functionality.
Such a class cannot be loaded with the database::load()
or database::find() functions (Section 3.9,
"Loading Persistent Objects"), updated with the
database::update() function (Section 3.10,
"Updating Persistent Objects"), or deleted with the
database::erase() function (Section 3.11,
"Deleting Persistent Objects"). To load and delete
objects without ids you can use the database::query()
(Chapter 4, "Querying the Database") and
database::erase_query() (Section 3.11,
"Deleting Persistent Objects") functions, respectively.
There is no way to update such objects except by using native SQL
statements (Section 3.12, "Executing Native SQL
Statements").

Furthermore, persistent classes without object ids cannot have container
data members nor can they be used in object relationships. Such objects
are not entered into the session object cache
(Section 10.1, "Object Cache") either.

To declare a persistent class with an object id, use the data member
id specifier (Section 12.4.1,
"id").

12.1.7 callback

The callback specifier specifies the persist class
member function that should be called before and after a
database operation is performed on an object of this class.
For example:


#include <odb/callback.hxx>

#pragma db object callback(init)
class person
{
...

void
init (odb::callback_event, odb::database&);
};


The callback function has the following signature and can be
overloaded for constant objects:


void
name (odb::callback_event, odb::database&);

void
name (odb::callback_event, odb::database&) const;


The first argument to the callback function is the event that
triggered this call. The odb::callback_event
enum-like type is defined in the <odb/callback.hxx>
header file and has the following interface:


namespace odb
{
struct callback_event
{
enum value
{
pre_persist,
post_persist,
pre_load,
post_load,
pre_update,
post_update,
pre_erase,
post_erase
};

callback_event (value v);
operator value () const;
};
}


The second argument to the callback function is the database
on which the operation is about to be performed or has just
been performed. A callback function can be inline or virtual.

The callback function for the *_persist,
*_update, and *_erase events is always
called on the constant object reference while for the *_load
events — always on the unrestricted reference.

If only the non-const version of the callback function
is provided, then only the *_load events will be delivered.
If only the const version is provided, then all the
events will be delivered to this function. Finally, if both versions
are provided, then the *_load events will be delivered
to the non-const version while all others — to the
const version. If you need to modify the object in one
of the "const" events, then you can safely cast away
const-ness using the const_cast operator if
you know that none of the objects will be created const. Alternatively,
if you cannot make this assumption, then you can declare the data
members you wish to modify as mutable.

A database operations callback can be used to implement object-specific
pre and post initializations, registrations, and cleanups. As an example,
the following code fragment outlines an implementation of a
person class that maintains the transient age
data member in addition to the persistent date of birth. A callback
is used to calculate the value of the former from the latter every
time a person object is loaded from the database.


#include <odb/core.hxx>
#include <odb/callback.hxx>

#pragma db object callback(init)
class person
{
...

private:
friend class odb::access;

date born_;

#pragma db transient
unsigned short age_;

void
init (odb::callback_event e, odb::database&)
{
switch (e)
{
case odb::callback_event::post_load:
{
// Calculate age from the date of birth.
...
break;
}
default:
break;
}
}
};


12.1.8 schema

The schema specifier specifies a database schema
that should be used for the persistent class.

In relational databases the term schema can refer to two related
but ultimately different concepts. Normally it means a collection
of tables, indexes, sequences, etc., that are created in the
database or the actual DDL statements that create these
database objects. Some database implementations support what
would be more accurately called a database namespace
but is also called a schema. In this sense, a schema is a
separate namespace in which tables, indexes, sequences, etc.,
can be created. For example, two tables that have the same
name can coexist in the same database if they belong to
different schemas. In this section when we talk about a
schema, we refer to the database namespace meaning
of this term.

When schemas are in use, a database object name is qualified
with a schema. For example:


CREATE TABLE accounting.employee (...)

SELECT ... FROM accounting.employee WHERE ...


In the above example accounting is the schema
and the employee table belongs to this
schema.

Not all database implementations support schemas. Some
implementation that don't support schemas (for example,
MySQL, SQLite) allow the use of the above syntax to specify
the database name. Yet others may support several levels
of qualification. For example, Microsoft SQL Server has
three levels starting with the linked database server,
followed by the database, and then followed by
the schema:
server1.company1.accounting.employee.
While the actual meaning of the qualifier in a qualified name
vary from one database implementation to another, here we
refer to all of them collectively as a schema.

In ODB, a schema for a table of a persistent class can be
specified at the class level, C++ namespace level, or the
file level. To assign a schema to a specific persistent class
we can use the schema specifier, for example:


#pragma db object schema("accounting")
class employee
{
...
};


If we are also assigning a table name, then we can use
a shorter notation by specifying both the schema and
the table name in the table specifier:


#pragma db object table("accounting.employee")
class employee
{
...
};


If we want to assign a schema to all the persistent classes
in a C++ namespace, then, instead of specifying the schema
for each class, we can specify it once at the C++ namespace level.
For example:


#pragma db namespace schema("accounting")
namespace accounting
{
#pragma db object
class employee
{
...
};

#pragma db object
class employer
{
...
};
}


If we want to assign a schema to all the persistent classes in
a file, then we can use the --schema ODB compiler
option. For example:


odb ... --schema accounting ...


An alternative to this approach with the same effect is to
assign a schema to the global namespace:


#pragma db namespace() schema("accounting")


By default schema qualifications are accumulated starting from
the persistent class, continuing with the namespace hierarchy
to which this class belongs, and finishing with the schema
specified with the --schema option. For
example:


#pragma db namespace schema("audit_db")
namespace audit
{
#pragma db namespace schema("accounting")
namespace accounting
{
#pragma db object
class employee
{
...
};
}
}


If we compile the above code fragment with the
--schema server1 option, then the
employee table will have the
server1.audit_db.accounting.employee qualified
name.

In some situations we may want to prevent such accumulation
of the qualifications. To accomplish this we can use the
so-called fully-qualified names, which have the empty leading
name component. This is analogous to the C++ fully-qualified
names in the ::accounting::employee form. For
example:


#pragma db namespace schema("accounting")
namespace accounting
{
#pragma db object schema(".hr")
class employee
{
...
};

#pragma db object
class employer
{
...
};
}


In the above code fragment, the employee table will
have the hr.employee qualified name while the
employer — accounting.employer.
Note also that the empty leading name component is a special
ODB syntax and is not propagated to the actual database names
(using a name like .hr.employee to refer to a table
will most likely result in an error).

Auxiliary database objects for a persistent class, such as indexes,
sequences, triggers, etc., are all created in the same schema
as the class table. By default, this is also true for the
container tables. However, if you need to store a container
table in a different schema, then you can provide a qualified
name using the table specifier, for example:


#pragma db object table("accounting.employee")
class employee
{
...

#pragma db object table("operations.projects")
std::vector<std::string> projects_;
};


The standard syntax for qualified names used in the
schema and table specifiers as well
as the view column specifier (Section
12.4.10, "column (view)") has the
"name.name..."
form where, as discussed above, the leading name component
can be empty to denote a fully qualified name. This form, however,
doesn't work if one of the name components contains periods. To
support such cases the alternative form is available:
"name"."name"...
For example:


#pragma db object table("accounting_1.2"."employee")
class employee
{
...
};


Finally, to specify an unqualified name that contains periods
we can use the following special syntax:


#pragma db object schema(."accounting_1.2") table("employee")
class employee
{
...
};


Table prefixes (Section 12.5.2, "table")
can be used as an alternative to database schemas if the target
database system does not support schemas.

12.1.9 polymorphic

The polymorphic specifier specifies that the persistent
class is polymorphic. For more information on polymorphism support,
refer to Chapter 8, "Inheritance".

12.1.10 session

The session specifier specifies whether to enable
session support for the persistent class. For example:


#pragma db object session // Enable.
class person
{
...
};

#pragma db object session(true) // Enable.
class employee
{
...
};

#pragma db object session(false) // Disable.
class employer
{
...
};


Session support is disabled by default unless the
--generate-session ODB compiler option is specified
or session support is enabled at the namespace level
(Section 12.5.4, "session").
For more information on sessions, refer to Chapter
10, "Session".

12.1.11 definition

The definition specifier specifies an alternative
definition location for the persistent class. By
default, the ODB compiler generates the database support code for
a persistent class when we compile the header file that
defines this class. However, if the definition
specifier is used, then the ODB compiler will instead generate
the database support code when we compile the header file
containing this pragma.

For more information on this functionality, refer to
Section 12.3.7, "definition".

12.1.12 transient

The transient specifier instructs the ODB compiler to
treat all non-virtual data members in the persistent class as transient
(Section 12.4.1, "transient").
This specifier is primarily useful when declaring virtual data
members, as discussed in Section 12.4.13,
"virtual".

12.2 View Type Pragmas

A pragma with the view qualifier declares a C++ class
as a view type. The qualifier can be optionally followed,
in any order, by one or more specifiers summarized in the
table below:




Specifier
Summary
Section



object
object associated with a view
12.2.1



table
table associated with a view
12.2.2



query
view query condition
12.2.3



pointer
pointer type for a view
12.2.4



callback
database operations callback
12.2.5



definition
definition location for a view
12.2.6



transient
all non-virtual data members in a view are transient
12.2.7




For more information on view types refer to Chapter 9,
"Views".

12.2.1 object

The object specifier specifies a persistent class
that should be associated with the view. For more information
on object associations refer to Section 9.1, "Object
Views".

12.2.2 table

The table specifier specifies a database table
that should be associated with the view. For more information
on table associations refer to Section 9.2, "Table
Views".

12.2.3 query

The query specifier specifies a query condition
for an object or table view or a native SQL query for a native
view. An empty query specifier indicates that a
native SQL query is provided at runtime. For more information
on query conditions refer to Section 9.4, "View
Query Conditions". For more information on native SQL queries,
refer to Section 9.5, "Native Views".

12.2.4 pointer

The pointer specifier specifies the view pointer type
for the view class. Similar to objects, the view pointer type is used
to return dynamically allocated instances of a view class. The
semantics of the pointer specifier for a view are the
same as those of the pointer specifier for an object
(Section 12.1.2, "pointer").

12.2.5 callback

The callback specifier specifies the view class
member function that should be called before and after an
instance of this view class is created as part of the query
result iteration. The semantics of the callback
specifier for a view are similar to those of the
callback specifier for an object
(Section 12.1.7, "callback")
except that the only events that can trigger a callback
call in the case of a view are pre_load and
post_load.

12.2.6 definition

The definition specifier specifies an alternative
definition location for the view class. By
default, the ODB compiler generates the database support code for
a view class when we compile the header file that
defines this class. However, if the definition
specifier is used, then the ODB compiler will instead generate
the database support code when we compile the header file
containing this pragma.

For more information on this functionality, refer to
Section 12.3.7, "definition".

12.2.7 transient

The transient specifier instructs the ODB compiler
to treat all non-virtual data members in the view class as transient
(Section 12.4.1, "transient").
This specifier is primarily useful when declaring virtual data
members, as discussed in Section 12.4.13,
"virtual".

12.3 Value Type Pragmas

A pragma with the value qualifier describes a value
type. It can be optionally followed, in any order, by one or more
specifiers summarized in the table below:




Specifier
Summary
Section



type
database type for a value type
12.3.1



id_type
database type for a value type when used as an object id
12.3.2



null/not_null
type can/cannot be NULL
12.3.3



default
default value for a value type
12.3.4



options
database options for a value type
12.3.5



readonly
composite value type is read-only
12.3.6



definition
definition location for a composite value type
12.3.7



transient
all non-virtual data members in a composite value are transient
12.3.8



unordered
ordered container should be stored unordered
12.3.9



index_type
database type for a container's index type
12.3.10



key_type
database type for a container's key type
12.3.11



value_type
database type for a container's value type
12.3.12



value_null/value_not_null
container's value can/cannot be NULL
12.3.13



id_options
database options for a container's id column
12.3.14



index_options
database options for a container's index column
12.3.15



key_options
database options for a container's key column
12.3.16



value_options
database options for a container's value column
12.3.17



id_column
column name for a container's object id
12.3.18



index_column
column name for a container's index
12.3.19



key_column
column name for a container's key
12.3.20



value_column
column name for a container's value
12.3.21




Many of the value type specifiers have corresponding member type
specifiers with the same names (Section 12.4,
"Data Member Pragmas"). The behavior of such specifiers
for members is similar to that for value types. The only difference
is the scope. A particular value type specifier applies to all the
members of this value type that don't have a pre-member version
of the specifier, while the member specifier always applies only
to a single member. Also, with a few exceptions, member specifiers
take precedence over and override parameters specified with value
specifiers.

12.3.1 type

The type specifier specifies the native database type
that should be used for data members of this type. For example:


#pragma db value(bool) type("INT")

#pragma db object
class person
{
...

bool married_; // Mapped to INT NOT NULL database type.
};


The ODB compiler provides the default mapping between common C++
types, such as bool, int, and
std::string and the database types for each supported
database system. For more information on the default mapping,
refer to Part II, "Database Systems". The
null and not_null (Section
12.3.3, "null/not_null") specifiers
can be used to control the NULL semantics of a type.

In the above example we changed the mapping for the bool
type which is now mapped to the INT database type. In
this case, the value pragma is all that is necessary
since the ODB compiler will be able to figure out how to store
a boolean value as an integer in the database. However, there
could be situations where the ODB compiler will not know how to
handle the conversion between the C++ and database representations
of a value. Consider, as an example, a situation where the
boolean value is stored in the database as a string:


#pragma db value(bool) type("VARCHAR(5)")


The possible database values for the C++ true value could
be "true", or "TRUE", or "True".
Or, maybe, all of the above could be valid. The ODB compiler has no way
of knowing how your application wants to convert bool
to a string and back. To support such custom value type mappings,
ODB allows you to provide your own database conversion functions
by specializing the value_traits class template. The
mapping example in the odb-examples
package shows how to do this for all the supported database systems.

12.3.2 id_type

The id_type specifier specifies the native database type
that should be used for data members of this type that are designated as
object identifiers (Section 12.4.1,
"id"). In combination with the type
specifier (Section 12.3.1, "type")
id_type allows you to map a C++ type differently depending
on whether it is used in an ordinary member or an object id. For
example:


#pragma db value(std::string) type("TEXT") id_type("VARCHAR(128)")

#pragma db object
class person
{
...

#pragma db id
std::string email_; // Mapped to VARCHAR(128) NOT NULL.

std::string name_; // Mapped to TEXT NOT NULL.
};


Note that there is no corresponding member type specifier for
id_type since the desired result can be achieved
with just the type specifier, for example:


#pragma db object
class person
{
...

#pragma db id type("VARCHAR(128)")
std::string email_;
};


12.3.3 null/not_null

The null and not_null specifiers specify that
a value type or object pointer can or cannot be NULL,
respectively. By default, value types are assumed not to allow
NULL values while object pointers are assumed to
allow NULL values. Data members of types that allow
NULL values are mapped in a relational database to
columns that allow NULL values. For example:


using std::tr1::shared_ptr;

typedef shared_ptr<std::string> string_ptr;
#pragma db value(string_ptr) type("TEXT") null

#pragma db object
class person
{
...

string_ptr name_; // Mapped to TEXT NULL.
};

typedef shared_ptr<person> person_ptr;
#pragma db value(person_ptr) not_null


The NULL semantics can also be specified on the
per-member basis (Section 12.4.6,
"null/not_null"). If both a type and
a member have null/not_null specifiers,
then the member specifier takes precedence. If a member specifier
relaxes the NULL semantics (that is, if a member has
the null specifier and the type has the explicit
not_null specifier), then a warning is issued.

It is also possible to override a previously specified
null/not_null specifier. This is
primarily useful if a third-party type, for example,
one provided by a profile library (Part III,
"Profiles"), allows NULL values but in your
object model data members of this type should never be
NULL. In this case you can use the not_null
specifier to disable NULL values for this type for the
entire translation unit. For example:


// By default, null_string allows NULL values.
//
#include <null-string.hxx>

// Disable NULL values for all the null_string data members.
//
#pragma db value(null_string) not_null


For a more detailed discussion of the NULL semantics
for values, refer to Section 7.3, "Pointers and
NULL Value Semantics". For a more detailed
discussion of the NULL semantics for object pointers,
refer to Chapter 6, "Relationships".

12.3.4 default

The default specifier specifies the database default value
that should be used for data members of this type. For example:


#pragma db value(std::string) default("")

#pragma db object
class person
{
...

std::string name_; // Mapped to TEXT NOT NULL DEFAULT ''.
};


The semantics of the default specifier for a value type
are similar to those of the default specifier for a
data member (Section 12.4.7,
"default").

12.3.5 options

The options specifier specifies additional column
definition options that should be used for data members of this
type. For example:


#pragma db value(std::string) options("COLLATE binary")

#pragma db object
class person
{
...

std::string name_; // Mapped to TEXT NOT NULL COLLATE binary.
};


The semantics of the options specifier for a value type
are similar to those of the options specifier for a
data member (Section 12.4.8,
"options").

12.3.6 readonly

The readonly specifier specifies that the composite
value type is read-only. Changes to data members of a read-only
composite value type are ignored when updating the database
state of an object (Section 3.10, "Updating Persistent
Objects") containing such a value type. Note that this specifier
is only valid for composite value types. For example:


#pragma db value readonly
class person_name
{
...
};


Read-only and read-write composite values can derive from each other
without any restrictions. When a read-only value derives from a
read-write value, the resulting whole value is read-only, including
the part corresponding to the read-write base. On the other hand, when a
read-write value derives from a read-only value, all the data
members that correspond to the read-only base are treated as
read-only while the rest is treated as read-write.

Note that it is also possible to declare individual data members
(Section 12.4.12, "readonly")
as well as whole objects (Section 12.1.4,
"readonly") as read-only.

12.3.7 definition

The definition specifier specifies an alternative
definition location for the composite value type. By
default, the ODB compiler generates the database support code for
a composite value type when we compile the header file that
defines this value type. However, if the definition
specifier is used, then the ODB compiler will instead generate
the database support code when we compile the header file containing
this pragma.

This mechanism is primarily useful for converting third-party
types to ODB composite value types. In such cases we normally
cannot modify the header files to add the necessary pragmas.
It is also often inconvenient to compile these header files
with the ODB compiler. With the definition
specifier we can create a wrapper header that contains
the necessary pragmas and instructs the ODB compiler to generate
the database support code for a third-party type when we compile
the wrapper header. As an example, consider struct timeval
that is defined in the <sys/time.h> system header.
This type has the following (or similar) definition:


struct timeval
{
long tv_sec;
long tv_usec;
};


If we would like to make this type an ODB composite value type,
then we can create a wrapper header, for example
time-mapping.hxx, with the following content:


#ifndef TIME_MAPPING_HXX
#define TIME_MAPPING_HXX

#include <sys/time.h>

#pragma db value(timeval) definition
#pragma db member(timeval::tv_sec) column("sec")
#pragma db member(timeval::tv_usec) column("usec")

#endif // TIME_MAPPING_HXX


If we now compile this header with the ODB compiler, the
resulting time-mapping-odb.?xx files will
contain the database support code for struct timeval.
To use timeval in our persistent classes, we simply
include the time-mapping.hxx header:


#include <sys/time.h>
#include "time-mapping.hxx"

#pragma db object
class object
{
timeval timestamp;
};


12.3.8 transient

The transient specifier instructs the ODB compiler
to treat all non-virtual data members in the composite value type
as transient (Section 12.4.1,
"transient"). This specifier is primarily useful
when declaring virtual data members, as discussed in
Section 12.4.13, "virtual".

12.3.9 unordered

The unordered specifier specifies that the ordered
container should be stored unordered in the database. The database
table for such a container will not contain the index column
and the order in which elements are retrieved from the database may
not be the same as the order in which they were stored. For example:


typedef std::vector<std::string> names;
#pragma db value(names) unordered


For a more detailed discussion of ordered containers and their
storage in the database, refer to Section 5.1,
"Ordered Containers".

12.3.10 index_type

The index_type specifier specifies the native
database type that should be used for the ordered container's
index column. The semantics of index_type
are similar to those of the type specifier
(Section 12.3.1, "type"). The native
database type is expected to be an integer type. For example:


typedef std::vector<std::string> names;
#pragma db value(names) index_type("SMALLINT UNSIGNED")


12.3.11 key_type

The key_type specifier specifies the native
database type that should be used for the map container's
key column. The semantics of key_type
are similar to those of the type specifier
(Section 12.3.1, "type"). For
example:


typedef std::map<unsigned short, float> age_weight_map;
#pragma db value(age_weight_map) key_type("INT UNSIGNED")


12.3.12 value_type

The value_type specifier specifies the native
database type that should be used for the container's
value column. The semantics of value_type
are similar to those of the type specifier
(Section 12.3.1, "type"). For
example:


typedef std::vector<std::string> names;
#pragma db value(names) value_type("VARCHAR(255)")


The value_null and value_not_null
(Section 12.3.13,
"value_null/value_not_null") specifiers
can be used to control the NULL semantics of a value column.

12.3.13 value_null/value_not_null

The value_null and value_not_null specifiers
specify that the container type's element value can or cannot be
NULL, respectively. The semantics of value_null
and value_not_null are similar to those of the
null and not_null specifiers
(Section 12.3.3, "null/not_null").
For example:


using std::tr1::shared_ptr;

#pragma db object
class account
{
...
};

typedef std::vector<shared_ptr<account> > accounts;
#pragma db value(accounts) value_not_null


For set and multiset containers (Section 5.2, "Set and
Multiset Containers") the element value is automatically treated
as not allowing a NULL value.


12.3.14 id_options

The id_options specifier specifies additional
column definition options that should be used for the container's
id column. For example:


typedef std::vector<std::string> nicknames;
#pragma db value(nicknames) id_options("COLLATE binary")


The semantics of the id_options specifier for a container
type are similar to those of the id_options specifier for
a container data member (Section 12.4.24,
"id_options").


12.3.15 index_options

The index_options specifier specifies additional
column definition options that should be used for the container's
index column. For example:


typedef std::vector<std::string> nicknames;
#pragma db value(nicknames) index_options("ZEROFILL")


The semantics of the index_options specifier for a container
type are similar to those of the index_options specifier for
a container data member (Section 12.4.25,
"index_options").


12.3.16 key_options

The key_options specifier specifies additional
column definition options that should be used for the container's
key column. For example:


typedef std::map<std::string, std::string> properties;
#pragma db value(properties) key_options("COLLATE binary")


The semantics of the key_options specifier for a container
type are similar to those of the key_options specifier for
a container data member (Section 12.4.26,
"key_options").


12.3.17 value_options

The value_options specifier specifies additional
column definition options that should be used for the container's
value column. For example:


typedef std::set<std::string> nicknames;
#pragma db value(nicknames) value_options("COLLATE binary")


The semantics of the value_options specifier for a container
type are similar to those of the value_options specifier for
a container data member (Section 12.4.27,
"value_options").


12.3.18 id_column

The id_column specifier specifies the column
name that should be used to store the object id in the
container's table. For example:


typedef std::vector<std::string> names;
#pragma db value(names) id_column("id")


If the column name is not specified, then object_id
is used by default.

12.3.19 index_column

The index_column specifier specifies the column
name that should be used to store the element index in the
ordered container's table. For example:


typedef std::vector<std::string> names;
#pragma db value(names) index_column("name_number")


If the column name is not specified, then index
is used by default.

12.3.20 key_column

The key_column specifier specifies the column
name that should be used to store the key in the map
container's table. For example:


typedef std::map<unsigned short, float> age_weight_map;
#pragma db value(age_weight_map) key_column("age")


If the column name is not specified, then key
is used by default.

12.3.21 value_column

The value_column specifier specifies the column
name that should be used to store the element value in the
container's table. For example:


typedef std::map<unsigned short, float> age_weight_map;
#pragma db value(age_weight_map) value_column("weight")


If the column name is not specified, then value
is used by default.




12.4 Data Member Pragmas

A pragma with the member qualifier or a positioned
pragma without a qualifier describes a data member. It can
be optionally followed, in any order, by one or more specifiers
summarized in the table below:




Specifier
Summary
Section



id
member is an object id
12.4.1



auto
id is assigned by the database
12.4.2



type
database type for a member
12.4.3



id_type
database type for a member when used as an object id
12.4.4



get/set/access
member accessor/modifier expressions
12.4.5



null/not_null
member can/cannot be NULL
12.4.6



default
default value for a member
12.4.7



options
database options for a member
12.4.8



column
column name for a member of an object or composite value
12.4.9



column
column name for a member of a view
12.4.10



transient
member is not stored in the database
12.4.11



readonly
member is read-only
12.4.12



virtual
declare a virtual data member
12.4.13



inverse
member is an inverse side of a bidirectional relationship
12.4.14



version
member stores object version
12.4.15



index
define database index for a member
12.4.16



unique
define unique database index for a member
12.4.17



unordered
ordered container should be stored unordered
12.4.18



table
table name for a container
12.4.19



index_type
database type for a container's index type
12.4.20



key_type
database type for a container's key type
12.4.21



value_type
database type for a container's value type
12.4.22



value_null/value_not_null
container's value can/cannot be NULL
12.4.23



id_options
database options for a container's id column
12.4.24



index_options
database options for a container's index column
12.4.25



key_options
database options for a container's key column
12.4.26



value_options
database options for a container's value column
12.4.27



id_column
column name for a container's object id
12.4.28



index_column
column name for a container's index
12.4.29



key_column
column name for a container's key
12.4.30



value_column
column name for a container's value
12.4.31




Many of the member specifiers have corresponding value type
specifiers with the same names (Section 12.3,
"Value Type Pragmas"). The behavior of such specifiers
for members is similar to that for value types. The only difference
is the scope. A particular value type specifier applies to all the
members of this value type that don't have a pre-member version
of the specifier, while the member specifier always applies only
to a single member. Also, with a few exceptions, member specifiers
take precedence over and override parameters specified with value
specifiers.

12.4.1 id

The id specifier specifies that the data member contains
the object id. In a relational database, an identifier member is
mapped to a primary key. For example:


#pragma db object
class person
{
...

#pragma db id
std::string email_;
};


Normally, every persistent class has a data member designated as an
object's identifier. However, it is possible to declare a
persistent class without an id using the object no_id
specifier (Section 12.1.6, "no_id").

Note also that the id specifier cannot be used for data
members of composite value types or views.

12.4.2 auto

The auto specifier specifies that the object's identifier
is automatically assigned by the database. Only a member that was
designated as an object id can have this specifier. For example:


#pragma db object
class person
{
...

#pragma db id auto
unsigned long id_;
};


Note that automatically-assigned object ids are not reused.
If you have a high object turnover (that is, objects are routinely
made persistent and then erased), then care must be taken not to
run out of object ids. In such situations, using
unsigned long long as the identifier type
is a safe choice.

For additional information on the automatic identifier assignment,
refer to Section 3.8, "Making Objects Persistent".

Note also that the auto specifier cannot be specified
for data members of composite value types or views.

12.4.3 type

The type specifier specifies the native database type
that should be used for the data member. For example:


#pragma db object
class person
{
...

#pragma db type("INT")
bool married_;
};


The null and not_null (Section
12.4.6, "null/not_null") specifiers
can be used to control the NULL semantics of a data member. It is
also possible to specify the database type on the per-type instead
of the per-member basis using the value type
specifier (Section 12.3.1, "type").

12.4.4 id_type

The id_type specifier specifies the native database type
that should be used for the data member when it is part of an
object identifier. This specifier only makes sense when applied to
a member of a composite value type that is used for both id and
non-id members. For example:


#pragma db value
class name
{
...

#pragma db type("VARCHAR(256)") id_type("VARCHAR(64)")
std::string first_;

#pragma db type("VARCHAR(256)") id_type("VARCHAR(64)")
std::string last_;
};

#pragma db object
class person
{
...

#pragma db id
name name_; // name_.first_, name_.last_ mapped to VARCHAR(64)

name alias_; // alias_.first_, alias_.last_ mapped to VARCHAR(256)
};


12.4.5 get/set/access

The get and set specifiers specify the
data member accessor and modifier expressions, respectively. If
provided, the generated database support code will use these
expressions to access and modify the data member when performing
database operations. The access specifier can be used
as a shortcut to specify both the accessor and modifier if they
happen to be the same.

In its simplest form the accessor or modifier expression can be
just a name. Such a name should resolve either to another data
member of the same type or to a suitable accessor or modifier
member function. For example:


#pragma db object
class person
{
...

public:
const std::string& name () const;
void name (const std::string&);
private:
#pragma db access(name)
std::string name_;
};


A suitable accessor function is a const member function
that takes no arguments and whose return value can be implicitly
converted to the const reference to the member type
(const std::string& in the example above).
An accessor function that returns a const reference
to the data member is called by-reference accessor.
Otherwise, it is called by-value accessor.

A suitable modifier function can be of two forms. It can be the
so called by-reference modifier which is a member function
that takes no arguments and returns a non-const reference
to the data member (std::string& in the example above).
Alternatively, it can be the so called by-value modifier which
is a member function taking a single argument — the new value
— that can be implicitly initialized from a variable of the member
type (std::string in the example above). The return value
of a by-value modifier, if any, is ignored. If both by-reference and
by-value modifiers are available, then ODB prefers the by-reference
version since it is more efficient. For example:


#pragma db object
class person
{
...

public:
std::string get_name () const; // By-value accessor.
std::string& set_name (); // By-reference modifier.
void set_name (std::string const&); // By-value modifier.
private:
#pragma db get(get_name) \ // Uses by-value accessor.
set(set_name) // Uses by-reference modifier.
std::string name_;
};


Note that in many cases it is not necessary to specify accessor and
modifier functions explicitly since the ODB compiler will try to
discover them automatically in case the data member will be inaccessible
to the generated code. In particular, in both of the above examples
the ODB compiler would have successfully discovered the necessary
functions. For more information on this functionality, refer to
Section 3.2, "Declaring Persistent Objects and
Values".

Note also that by-value accessors and by-value modifiers cannot be
used for certain data members in certain situations. These limitations
are discussed in more detail later in this section.

Accessor and modifier expressions can be more elaborate than simple
names. An accessor expression is any C++ expression that can be
used to initialize a const reference to the member
type. Similar to accessor functions, which are just a special case
of accessor expressions, an accessor expression that evaluates to a
const reference to the data member is called
by-reference accessor expression. Otherwise, it is
called by-value accessor expression.

Modifier expressions can also be of two forms: by-reference
modifier expression and by-value modifier expression
(again, modifier functions are just a special case of modifier
expressions). A by-reference modifier expression is any C++
expression that evaluates to the non-const reference
to the member type. A by-value modifier expression can be a
single or multiple (separated by semicolon) C++ statements
with the effect of setting the new member value.

There are two special placeholders that are recognized by the
ODB compiler in accessor and modifier expressions. The first
is the this keyword which denotes a reference
(note: not a pointer) to the persistent object. In accessor
expressions this reference is const while in
modifier expressions it is non-const. If an
expression does not contain the this placeholder,
then the ODB compiler automatically prefixes it with this.
sequence.

The second placeholder, the (?) sequence, is used
to denote the new value in by-value modifier expressions. The
ODB compiler replaces the question mark with the variable name,
keeping the surrounding parenthesis. The following example shows
a few more interesting accessor and modifier expressions:


#pragma db value
struct point
{
point (int, int);

int x;
int y;
};

#pragma db object
class person
{
...

public:
const char* name () const;
void name (const char*);
private:
#pragma db get(std::string (this.name ())) \
set(name ((?).c_str ())) // The same as this.name (...).
std::string name_;

public:
const std::unique_ptr<account>& acc () const;
void acc (std::unique_ptr<account>);
private:
#pragma db set(acc (std::move (?)))
std::unique_ptr<account> acc_;

public:
int loc_x () const
int loc_y () const
void loc_x (int);
void loc_y (int);
private:
#pragma db get(point (this.loc_x (), this.loc_y ())) \
set(this.loc_x ((?).x); this.loc_y ((?).y))
point loc_;
};


When the data member is of an array type, then the terms "reference"
and "member type" in the above discussion should be replaced with
"pointer" and "array element type", respectively. That is, the accessor
expression for an array member is any C++ expression that can be
used to initialize a const pointer to the array
element type, and so on. The following example shows common
accessor and modifier signatures for array members:


#pragma db object
class person
{
...

public:
const char* id () const; // By-reference accessor.
void id (const char*); // By-value modifier.
private:
char id_[16];

public:
const char* pub_key () const; // By-reference accessor.
char* pub_key (); // By-reference modifier.
private:
char pub_key_[2048];
};


Accessor and modifier expressions can be used with data members
of simple value, composite value, container, and object pointer
types. They can be used for data members in persistent classes,
composite value types, and views. There is also a mechanism
related to accessors and modifiers called virtual data members
and which is discussed in Section 12.4.13,
"virtual".

There are, however, certain limitations when it comes to using
by-value accessor and modifier expressions. First of all, if a
by-value modifier is used, then the data member type should be
default-constructible. Furthermore, a composite value type that
has a container member cannot be modified with a by-value modifier.
Only a by-reference modifier expression can be used. The ODB
compiler will detect such cases and issue diagnostics. For
example:


#pragma db value
struct name
{
std::string first_;
std::string last_;
std::vector<std::string> aliases_;
};

#pragma db object
class person
{
...

public:
const name& name () const;
void name (const name&);
private:
#pragma db access(name) // Error: by-value modifier.
name name_;
};


In certain database systems it is also not possible to use by-value
accessor and modifier expression with certain database types.
The ODB compiler is only able to detect such cases and issue diagnostics
if you specified accessor/modifier function names as opposed to custom
expressions. For more information on these database and type-specific
limitations, refer to the "Limitations" sections in Part
II, "Database Systems".

12.4.6 null/not_null

The null and not_null specifiers specify that
the data member can or cannot be NULL, respectively.
By default, data members of basic value types for which database
mapping is provided by the ODB compiler do not allow NULL
values while data members of object pointers allow NULL
values. Other value types, such as those provided by the profile
libraries (Part III, "Profiles"), may or may
not allow NULL values, depending on the semantics
of each value type. Consult the relevant documentation to find
out more about the NULL semantics for such value
types. A data member containing the object id (Section
12.4.1, "id") is automatically treated as not
allowing a NULL value. Data members that
allow NULL values are mapped in a relational database
to columns that allow NULL values. For example:


using std::tr1::shared_ptr;

#pragma db object
class person
{
...

#pragma db null
std::string name_;
};

#pragma db object
class account
{
...

#pragma db not_null
shared_ptr<person> holder_;
};


The NULL semantics can also be specified on the
per-type basis (Section 12.3.3,
"null/not_null"). If both a type and
a member have null/not_null specifiers,
then the member specifier takes precedence. If a member specifier
relaxes the NULL semantics (that is, if a member has
the null specifier and the type has the explicit
not_null specifier), then a warning is issued.

For a more detailed discussion of the NULL semantics
for values, refer to Section 7.3, "Pointers and
NULL Value Semantics". For a more detailed
discussion of the NULL semantics for object pointers,
refer to Chapter 6, "Relationships".

12.4.7 default

The default specifier specifies the database default value
that should be used for the data member. For example:


#pragma db object
class person
{
...

#pragma db default(-1)
int age_; // Mapped to INT NOT NULL DEFAULT -1.
};


A default value can be the special null keyword,
a bool literal (true or false),
an integer literal, a floating point literal, a string literal, or
an enumerator name. If you need to specify a default value that is
an expression, for example an SQL function call, then you can use
the options specifier (Section
12.4.8, "options") instead. For example:


enum gender {male, female, undisclosed};

#pragma db object
class person
{
...

#pragma db default(null)
odb::nullable<std::string> middle_; // DEFAULT NULL

#pragma db default(false)
bool married_; // DEFAULT 0/FALSE

#pragma db default(0.0)
float weight_; // DEFAULT 0.0

#pragma db default("Mr")
string title_; // DEFAULT 'Mr'

#pragma db default(undisclosed)
gender gender_; // DEFAULT 2/'undisclosed'

#pragma db options("DEFAULT CURRENT_TIMESTAMP()")
date timestamp_; // DEFAULT CURRENT_TIMESTAMP()
};


Default values specified as enumerators are only supported for
members that are mapped to an ENUM or an integer
type in the database, which is the case for the automatic
mapping of C++ enums to suitable database types as performed
by the ODB compiler. If you have mapped a C++ enum to another
database type, then you should use a literal corresponding
to that type to specify the default value. For example:


enum gender {male, female, undisclosed};
#pragma db value(gender) type("VARCHAR(11)")

#pragma db object
class person
{
...

#pragma db default("undisclosed")
gender gender_; // DEFAULT 'undisclosed'
};


A default value can also be specified on the per-type basis
(Section 12.3.4, "default").
An empty default specifier can be used to reset
a default value that was previously specified on the per-type
basis. For example:


#pragma db value(std::string) default("")

#pragma db object
class person
{
...

#pragma db default()
std::string name_; // No default value.
};


A data member containing the object id (Section
12.4.1, "id" ) is automatically treated as not
having a default value even if its type specifies a default value.

Note also that default values do not affect the generated C++ code
in any way. In particular, no automatic initialization of data members
with their default values is performed at any point. If you need such
an initialization, you will need to implement it yourself, for example,
in your persistent class constructors. The default values only
affect the generated database schemas and, in the context of ODB,
are primarily useful for schema evolution.

Additionally, the default specifier cannot be specified
for view data members.

12.4.8 options

The options specifier specifies additional column
definition options that should be used for the data member. For
example:


#pragma db object
class person
{
...

#pragma db options("CHECK(email != '')")
std::string email_; // Mapped to TEXT NOT NULL CHECK(email != '').
};


Options can also be specified on the per-type basis
(Section 12.3.5, "options").
By default, options are accumulating. That is, the ODB compiler
first adds all the options specified for a value type followed
by all the options specified for a data member. To clear the
accumulated options at any point in this sequence you can use
an empty options specifier. For example:


#pragma db value(std::string) options("COLLATE binary")

#pragma db object
class person
{
...

std::string first_; // TEXT NOT NULL COLLATE binary

#pragma db options("CHECK(email != '')")
std::string last_; // TEXT NOT NULL COLLATE binary CHECK(email != '')

#pragma db options()
std::string title_; // TEXT NOT NULL

#pragma db options() options("CHECK(email != '')")
std::string email_; // TEXT NOT NULL CHECK(email != '')
};


ODB provides dedicated specifiers for specifying column types
(Section 12.4.3, "type"),
NULL constraints (Section 12.4.6,
"null/not_null"), and default
values (Section 12.4.7, "default").
For ODB to function correctly these specifiers should always be
used instead of the opaque options specifier for
these components of a column definition.

Note also that the options specifier cannot be specified
for view data members.

12.4.9 column (object, composite value)

The column specifier specifies the column name
that should be used to store the data member of a persistent class
or composite value type in a relational database. For example:


#pragma db object
class person
{
...

#pragma db id column("person_id")
unsigned long id_;
};


For a member of a composite value type, the column specifier
specifies the column name prefix. Refer to Section 7.2.2,
"Composite Value Column and Table Names" for details.

If the column name is not specified, it is derived from the member's
so-called public name. A public member name is obtained by removing
the common data member name decorations, such as leading and trailing
underscores, the m_ prefix, etc.

12.4.10 column (view)

The column specifier can be used to specify the associated
object data member, the potentially qualified column name, or the column
expression for the data member of a view class. For more information,
refer to Section 9.1, "Object Views" and
Section 9.2, "Table Views".

12.4.11 transient

The transient specifier instructs the ODB compiler
not to store the data member in the database. For example:


#pragma db object
class person
{
...

date born_;

#pragma db transient
unsigned short age_; // Computed from born_.
};


This pragma is usually used on computed members, pointers and
references that are only meaningful in the application's
memory, as well as utility members such as mutexes, etc.

12.4.12 readonly

The readonly specifier specifies that the data member of
an object or composite value type is read-only. Changes to a read-only
data member are ignored when updating the database state of an object
(Section 3.10, "Updating Persistent Objects")
containing such a member. Since views are read-only, it is not
necessary to use this specifier for view data members. Object id
(Section 12.4.1, "id")
and inverse (Section 12.4.14,
"inverse") data members are automatically treated
as read-only and must not be explicitly declared as such. For
example:


#pragma db object
class person
{
...

#pragma db readonly
date born_;
};


Besides simple value members, object pointer, container, and composite
value members can also be declared read-only. A change of a pointed-to
object is ignored when updating the state of a read-only object
pointer. Similarly, any changes to the number or order of
elements or to the element values themselves are ignored when
updating the state of a read-only container. Finally, any changes
to the members of a read-only composite value type are also ignored
when updating the state of such a composite value.

ODB automatically treats const data members as read-only.
For example, the following person object is equivalent
to the above declaration for the database persistence purposes:


#pragma db object
class person
{
...

const date born_; // Automatically read-only.
};


When declaring an object pointer const, make sure to
declare the pointer as const rather than (or in addition
to) the object itself. For example:


#pragma db object
class person
{
...

const person* father_; // Read-write pointer to a read-only object.
person* const mother_; // Read-only pointer to a read-write object.
};


Note that in case of a wrapper type (Section 7.3,
"Pointers and NULL Value Semantics"), both the
wrapper and the wrapped type must be const in
order for the ODB compiler to automatically treat the data
member as read-only. For example:


#pragma db object
class person
{
...

const std::auto_ptr<const date> born_;
};


Read-only members are useful when dealing with
asynchronous changes to the state of a data member in the
database which should not be overwritten. In other cases,
where the state of a data member never changes, declaring such a member
read-only allows ODB to perform more efficient object updates.
In such cases, however, it is conceptually more correct to
declare such a data member as const rather than
as read-only.

Note that it is also possible to declare composite value types
(Section 12.3.6, "readonly")
as well as whole objects (Section 12.1.4,
"readonly") as read-only.

12.4.13 virtual

The virtual specifier is used to declare a virtual
data member in an object, view, or composite value type. A virtual
data member is an imaginary data member that is only
used for the purpose of database persistence. A virtual data
member does not actually exist (that is, occupy space) in the
C++ class. Note also that virtual data members have nothing to
do with C++ virtual functions or virtual inheritance. Specifically,
no virtual function call overhead is incurred when using virtual
data members.

To declare a virtual data member we must specify the data
member name using the member specifier. We must
also specify the data member type with the virtual
specifier. Finally, the virtual data member declaration must
also specify the accessor and modifier expressions, unless
suitable accessor and modifier functions can automatically be
found by the ODB compiler (Section 12.4.5,
"get/set/access").
For example:


#pragma db object
class person
{
...

// Transient real data member that actually stores the data.
//
#pragma db transient
std::string name_;

// Virtual data member.
//
#pragma db member(name) virtual(std::string) access(name_)
};


From the pragma language point of view, a virtual data member
behaves exactly like a normal data member. Specifically, we
can reference the virtual data member after it has been
declared and use positioned pragmas before its declaration.
For example:


#pragma db object
class person
{
...

#pragma db transient
std::string name_;

#pragma db access(name_)
#pragma db member(name) virtual(std::string)
};

#pragma db member(person::name) column("person_name")
#pragma db index member(person::name)


We can also declare a virtual data member outside the class
scope:


#pragma db object
class person
{
...

std::string name_;
};

#pragma db member(person::name_) transient
#pragma db member(person::name) virtual(std::string) access(name_)


While in the above examples using virtual data members doesn't
seem to yield any benefits, this mechanism can be useful in a
number of situations. As one example, consider the need to
aggregate or dis-aggregate a data member:


#pragma db object
class person
{
...

#pragma db transient
std::pair<std::string, std::string> name_;

#pragma db member(first) virtual(std::string) access(name_.first)
#pragma db member(last) virtual(std::string) access(name_.second)
};


We can also use virtual data members to implement composite
object ids that are spread over multiple data members:


#pragma db value
struct name
{
name () {}
name (std::string const& f, std::string const& l)
: first (f), last(l) {}

std::string first;
std::string last;
};

#pragma db object
class person
{
...

#pragma db transient
std::string first_;

#pragma db transient
std::string last_;

#pragma db member(name) virtual(name) id \
get(::name (this.first_, this.last_)) \
set(this.first_ = (?).first; this.last_ = (?).last)
};


Another common situation that calls for virtual data members is
a class that uses the pimpl idiom. While the following code
fragment outlines the idea, for details refer to the
pimpl example in the odb-examples
package.


#pragma db object
class person
{
public:
std::string const& name () const;
void name (std::string const&);

unsigned short age () const;
void age (unsigned short);

...

private:
class impl;

#pragma db transient
impl* pimpl_;

#pragma db member(name) virtual(std::string) // Uses name().
#pragma db member(age) virtual(unsigned short) // Uses age().
};


The above example also shows that names used for virtual data
members (name and age in our case) can
be the same as the names of accessor/modifier functions. The only
names that virtual data members cannot clash with are those of
other data members, virtual or real.

A common pattern in the above examples is the need to
declare the real data member that actually stores the
data as transient. If all the real data members in a
class are treated as transient, then we can use the
class-level transient specifier
(Section 12.1.12, "transient
(object)",
Section 12.3.8, "transient
(composite value)",
Section 12.2.7, "transient
(view)")
instead of doing it for each individual member. For example:


#pragma db object transient
class person
{
...

std::string first_; // Transient.
std::string last_; // Transient.

#pragma db member(name) virtual(name) ...
};


The ability to treat all the real data members as transient
becomes more important if we don't know the names of these
data members. This is often the case when we are working
with third-party types that document the accessor and
modifier functions but not the names of their private data
members. As an example, consider the point class
defined in a third-party <point> header file:


class point
{
public:
point ();
point (int x, int y);

int x () const;
int y () const;

void x (int);
void y (int);

private:
...
};


To convert this class to an ODB composite value type we could
create the point-mapping.hxx file with the following
content:


#include <point>

#pragma db value(point) transient definition
#pragma db member(point::x) virtual(int)
#pragma db member(point::y) virtual(int)


Virtual data members can be of simple value, composite value,
container, or object pointer types. They can be used in persistent
classes, composite value types, and views.

12.4.14 inverse

The inverse specifier specifies that the data member of
an object pointer or a container of object pointers type is an
inverse side of a bidirectional object relationship. The single
required argument to this specifier is the corresponding data
member name in the referenced object. For example:


using std::tr1::shared_ptr;
using std::tr1::weak_ptr;

class person;

#pragma db object pointer(shared_ptr)
class employer
{
...

std::vector<shared_ptr<person> > employees_;
};

#pragma db object pointer(shared_ptr)
class person
{
...

#pragma db inverse(employee_)
weak_ptr<employer> employer_;
};


An inverse member does not have a corresponding column or, in case
of a container, table in the resulting database schema. Instead, the
column or table from the referenced object is used to retrieve the
relationship information. Only ordered and set containers can be used
for inverse members. If an inverse member is of an ordered container
type, it is automatically marked as unordered
(Section 12.4.18, "unordered").

For a more detailed discussion of inverse members, refer to
Section 6.2, "Bidirectional Relationships".

12.4.15 version

The version specifier specifies that the data member stores
the object version used to support optimistic concurrency. If a class
has a version data member, then it must also be declared as having the
optimistic concurrency model using the optimistic pragma
(Section 12.1.5, "optimistic"). For
example:


#pragma db object optimistic
class person
{
...

#pragma db version
unsigned long version_;
};


A version member must be of an integral C++ type and must map to
an integer or similar database type. Note also that object versions
are not reused. If you have a high update frequency, then care must
be taken not to run out of versions. In such situations, using
unsigned long long as the version type is a safe
choice.

For a more detailed discussion of optimistic concurrency, refer to
Chapter 11, "Optimistic Concurrency".

12.4.16 index

The index specifier instructs the ODB compiler to define
a database index for the data member. For example:


#pragma db object
class person
{
...

#pragma db index
std::string name_;
};


For more information on defining database indexes, refer to
Section 12.6, "Index Definition Pragmas".

12.4.17 unique

The index specifier instructs the ODB compiler to define
a unique database index for the data member. For example:


#pragma db object
class person
{
...

#pragma db unique
std::string name_;
};


For more information on defining database indexes, refer to
Section 12.6, "Index Definition Pragmas".

12.4.18 unordered

The unordered specifier specifies that the member of
an ordered container type should be stored unordered in the database.
The database table for such a member will not contain the index column
and the order in which elements are retrieved from the database may
not be the same as the order in which they were stored. For example:


#pragma db object
class person
{
...

#pragma db unordered
std::vector<std::string> nicknames_;
};


For a more detailed discussion of ordered containers and their
storage in the database, refer to Section 5.1,
"Ordered Containers".

12.4.19 table

The table specifier specifies the table name that should
be used to store the contents of the container member. For example:


#pragma db object
class person
{
...

#pragma db table("nicknames")
std::vector<std::string> nicknames_;
};


If the table name is not specified, then the container table name
is constructed by concatenating the object's table name, underscore,
and the public member name. The public member name is obtained
by removing the common member name decorations, such as leading and
trailing underscores, the m_ prefix, etc. In the example
above, without the table specifier, the container's
table name would have been person_nicknames.

The table specifier can also be used for members of
composite value types. In this case it specifies the table name
prefix for container members inside the composite value type. Refer
to Section 7.2.2, "Composite Value Column and Table
Names" for details.

The container table name can be qualified with a database
schema, for example:


#pragma db object
class person
{
...

#pragma db table("extras.nicknames")
std::vector<std::string> nicknames_;
};


For more information on database schemas and the format of the
qualified names, refer to Section 12.1.8,
"schema".

12.4.20 index_type

The index_type specifier specifies the native
database type that should be used for an ordered container's
index column of the data member. The semantics of index_type
are similar to those of the type specifier
(Section 12.4.3, "type"). The native
database type is expected to be an integer type. For example:


#pragma db object
class person
{
...

#pragma db index_type("SMALLINT UNSIGNED")
std::vector<std::string> nicknames_;
};


12.4.21 key_type

The key_type specifier specifies the native
database type that should be used for a map container's
key column of the data member. The semantics of key_type
are similar to those of the type specifier
(Section 12.4.3, "type"). For
example:


#pragma db object
class person
{
...

#pragma db key_type("INT UNSIGNED")
std::map<unsigned short, float> age_weight_map_;
};


12.4.22 value_type

The value_type specifier specifies the native
database type that should be used for a container's
value column of the data member. The semantics of value_type
are similar to those of the type specifier
(Section 12.4.3, "type"). For
example:


#pragma db object
class person
{
...

#pragma db value_type("VARCHAR(255)")
std::vector<std::string> nicknames_;
};


The value_null and value_not_null
(Section 12.4.23,
"value_null/value_not_null") specifiers
can be used to control the NULL semantics of a value column.

12.4.23 value_null/value_not_null

The value_null and value_not_null specifiers
specify that a container's element value for the data member can or
cannot be NULL, respectively. The semantics of
value_null and value_not_null are similar
to those of the null and not_null specifiers
(Section 12.4.6, "null/not_null").
For example:


using std::tr1::shared_ptr;

#pragma db object
class person
{
...
};

#pragma db object
class account
{
...

#pragma db value_not_null
std::vector<shared_ptr<person> > holders_;
};


For set and multiset containers (Section 5.2, "Set and
Multiset Containers") the element value is automatically treated
as not allowing a NULL value.

12.4.24 id_options

The id_options specifier specifies additional
column definition options that should be used for a container's
id column of the data member. For example:


#pragma db object
class person
{
...

#pragma db id options("COLLATE binary")
std::string name_;

#pragma db id_options("COLLATE binary")
std::vector<std::string> nicknames_;
};


The semantics of id_options are similar to those
of the options specifier (Section
12.4.8, "options").

12.4.25 index_options

The index_options specifier specifies additional
column definition options that should be used for a container's
index column of the data member. For example:


#pragma db object
class person
{
...

#pragma db index_options("ZEROFILL")
std::vector<std::string> nicknames_;
};


The semantics of index_options are similar to those
of the options specifier (Section
12.4.8, "options").

12.4.26 key_options

The key_options specifier specifies additional
column definition options that should be used for a container's
key column of the data member. For example:


#pragma db object
class person
{
...

#pragma db key_options("COLLATE binary")
std::map<std::string, std::string> properties_;
};


The semantics of key_options are similar to those
of the options specifier (Section
12.4.8, "options").

12.4.27 value_options

The value_options specifier specifies additional
column definition options that should be used for a container's
value column of the data member. For example:


#pragma db object
class person
{
...

#pragma db value_options("COLLATE binary")
std::set<std::string> nicknames_;
};


The semantics of value_options are similar to those
of the options specifier (Section
12.4.8, "options").

12.4.28 id_column

The id_column specifier specifies the column
name that should be used to store the object id in a
container's table for the data member. The semantics of
id_column are similar to those of the
column specifier
(Section 12.4.9, "column").
For example:


#pragma db object
class person
{
...

#pragma db id_column("person_id")
std::vector<std::string> nicknames_;
};


If the column name is not specified, then object_id
is used by default.

12.4.29 index_column

The index_column specifier specifies the column
name that should be used to store the element index in an
ordered container's table for the data member. The semantics of
index_column are similar to those of the
column specifier
(Section 12.4.9, "column").
For example:


#pragma db object
class person
{
...

#pragma db index_column("nickname_number")
std::vector<std::string> nicknames_;
};


If the column name is not specified, then index
is used by default.

12.4.30 key_column

The key_column specifier specifies the column
name that should be used to store the key in a map
container's table for the data member. The semantics of
key_column are similar to those of the
column specifier
(Section 12.4.9, "column").
For example:


#pragma db object
class person
{
...

#pragma db key_column("age")
std::map<unsigned short, float> age_weight_map_;
};


If the column name is not specified, then key
is used by default.

12.4.31 value_column

The value_column specifier specifies the column
name that should be used to store the element value in a
container's table for the data member. The semantics of
value_column are similar to those of the
column specifier
(Section 12.4.9, "column").
For example:


#pragma db object
class person
{
...

#pragma db value_column("weight")
std::map<unsigned short, float> age_weight_map_;
};


If the column name is not specified, then value
is used by default.

12.5 Namespace Pragmas

A pragma with the namespace qualifier describes a
C++ namespace. Similar to other qualifiers, namespace
can also refer to a named C++ namespace, for example:


namespace test
{
...
}

#pragma db namespace(test) ...


To refer to the global namespace in the namespace
qualifier the following special syntax is used:


#pragma db namespace() ....


The namespace qualifier can be optionally followed,
in any order, by one or more specifiers summarized in the
table below:




Specifier
Summary
Section



pointer
pointer type for persistent classes and views inside a namespace
12.5.1



table
table name prefix for persistent classes inside a namespace
12.5.2



schema
database schema for persistent classes inside a namespace
12.5.3



session
enable/disable session support for persistent classes inside a namespace
12.5.4




12.5.1 pointer

The pointer specifier specifies the default pointer
type for persistent classes and views inside the namespace. For
example:


#pragma db namespace pointer(std::tr1::shared_ptr)
namespace accounting
{
#pragma db object
class employee
{
...
};

#pragma db object
class employer
{
...
};
}


There are only two valid ways to specify a pointer with the
pointer specifier at the namespace level. We can
specify the template name of a smart pointer in which
case the ODB compiler will automatically append the class
name as a template argument. Or we can use *
to denote a raw pointer.

Note also that we can always override the default pointer
specified at the namespace level for any persistent class
or view inside this namespace. For example:


#pragma db namespace pointer(std::unique_ptr)
namespace accounting
{
#pragma db object pointer(std::shared_ptr)
class employee
{
...
};

#pragma db object
class employer
{
...
};
}


For a more detailed discussion of object and view pointers, refer
to Section 3.3, "Object and View Pointers".

12.5.2 table

The table specifier specifies a table prefix
that should be added to table names of persistent classes inside
the namespace. For example:


#pragma db namespace table("acc_")
namespace accounting
{
#pragma db object table("employees")
class employee
{
...
};

#pragma db object table("employers")
class employer
{
...
};
}


In the above example the resulting table names will be
acc_employees and acc_employers.

The table name prefix can also be specified with the
--table-prefix ODB compiler option. Note
that table prefixes specified at the namespace level as well
as with the command line option are accumulated. For example:


#pragma db namespace() table("audit_")

#pragma db namespace table("hr_")
namespace hr
{
#pragma db object table("employees")
class employee
{
...
};
}

#pragma db object table("employers")
class employer
{
...
};


If we compile the above example with the
--table-prefix test_ option, then the
employee class table will be called
test_audit_hr_employees and employer —
test_audit_employers.

Table prefixes can be used as an alternative to database schemas
(Section 12.1.8, "schema") if
the target database system does not support schemas.

12.5.3 schema

The schema specifier specifies a database schema
that should be used for persistent classes inside the namespace.
For more information on specifying a database schema refer to
Section 12.1.8, "schema".

12.5.4 session

The session specifier specifies whether to enable
session support for persistent classes inside the namespace. For
example:


#pragma db namespace session
namespace hr
{
#pragma db object // Enabled.
class employee
{
...
};

#pragma db object session(false) // Disabled.
class employer
{
...
};
}


Session support is disabled by default unless the
--generate-session ODB compiler option is specified.
Session support specified at the namespace level can be overridden
on the per object basis (Section 12.1.10,
"session"). For more information on sessions,
refer to Chapter 10, "Session".

12.6 Index Definition Pragmas

While it is possible to manually add indexes to the generated
database schema, it is more convenient to do this as part of
the persistent class definitions. A pragma with the index
qualifier describes a database index. It has the following
general format:


#pragma db index[("<name>")] \
[unique|type("<type>")] \
[method("<method>")] \
[options("<index-options>")] \
member(<name>[, "<column-options>"])... \
members(<name>[,<name>...])...


The index qualifier can optionally specify the
index name. If the index name is not specified, then one is
automatically derived by appending the _i suffix
to the column name of the index member. If the name is not
specified and the index contains multiple members, then the
index definition is invalid.

The optional type, method, and
options clauses specify the index type, for
example UNIQUE, index method, for example
BTREE, and index options, respectively. The
unique clause is a shortcut for
type("UNIQUE"). Note that not all database
systems support specifying an index method or options.
For more information on the database system-specific index
types, methods, and options, refer to Part II,
"Database Systems".

To specify index members we can use the member
or members clauses, or a mix of the two. The
member clause allows us to specify a single
index member with optional column options, for example,
"ASC". If we need to create a composite
index that contains multiple members, then we can repeat
the member clause several times or, if the
members don't have any column options, we can use a single
members clause instead. Similar to the index
type, method, and options, the format of column options is
database system-specific. For more details, refer to
Part II, "Database Systems".

The following code fragment shows some typical examples
of index definitions:


#pragma db object
class object
{
...

int x;
int y;
int z1;
int z2;

// An index for member x with automatically-assigned name x_i.
//
#pragma db index member(x)

// A unique index named y_index for member y which is sorted in
// the descending order. The index is using the BTREE method.
//
#pragma db index("y_index") unique method("BTREE") member(y, "DESC")

// A composite BITMAP index named z_i for members z1 and z2.
//
#pragma db index("z_i") type("BITMAP") members(z1, z2)
};


ODB also offers a shortcut for defining an index with the default
method and options for a single data member. Such an index can
be defined using the index (Section
12.4.16, "index") or unique
(Section 12.4.17, "unique")
member specifier. For example:


#pragma db object
class object
{
...

#pragma db index
int x;

#pragma db type("INT") unique
int y;
};


The above example is semantically equivalent to the following
more verbose version:


#pragma db object
class object
{
...

int x;

#pragma db type("INT")
int y;

#pragma db index member(x)
#pragma db index unique member(y)
};


While it is convenient to define an index inside a persistent
class, it is also possible to do that out of the class body. In this
case, the index name, if specified, must be prefixed with the
potentially-qualified class name. For example:


namespace n
{
#pragma db object
class object
{
...

int x;
int y;
};

// An index for member x in persistent class object with automatically-
// assigned name x_i.
//
#pragma db index(object) member(x)
}

// An index named y_index for member y in persistent class n::object.
//
#pragma db index(n::object::"y_index") member(y)


It is possible to define an index on a member that is of a
composite value type or on some of its nested members. For
example:


#pragma db value
struct point
{
int x;
int y;
int z;
};

#pragma db object
class object
{
// An index that includes all of the p1's nested members.
//
#pragma db index
point p1;

point p2;

// An index that includes only p2.x and p2.y.
//
#pragma db index("p2_xy_i") members(p2.x, p2.y)
};


When generating a schema for a container member (Chapter 5,
"Containers"), ODB automatically defines two indexes on the container
table. One is for the object id that references the object table and the
other is for the index column in case the container is ordered
(Section 5.1, "Ordered Containers"). By default these
indexes use the default index name, type, method, and options. The
index pragma allows us to customize these two indexes by
recognizing the special id and index nested
member names when specified after a container member. For example:


#pragma db object
class object
{
std::vector<int> v;

// Change the container id index name.
//
#pragma db index("id_index") member(v.id)

// Change the container index index method.
//
#pragma db index method("BTREE") member(v.index)
};


12.7 Database Type Mapping Pragmas

A pragma with the map qualifier describes a
mapping between two database types. For each database system
ODB provides built-in support for a core set of database types,
such as integers, strings, binary, etc. However, many database
systems provide extended types such as geospatial types,
user-defined types, and collections (arrays, table types,
key-value stores, etc). In order to support such extended types,
ODB allows us to map them to one of the built-in types, normally
a string or a binary. Given the text or binary representation
of the data we can then extract it into our chosen C++ data type
and thus establish a mapping between an extended database type and
its C++ equivalent.

The map pragma has the following format:


#pragma db map type("regex") as("subst") [to("subst")] [from("subst")]


The type clause specifies the name of the database type
that we are mapping. We will refer to it as the mapped type
from now on. The name of the mapped type is a Perl-like regular
expression pattern that is matched in the case-insensitive mode.

The as clause specifies the name of the database type
that we are mapping the mapped type to. We will refer to it as
the interface type from now on. The name of the interface
type is a regular expression substitution and should expand to a
name of a database type for which ODB provides built-in support.

The optional to and from clauses specify the
database conversion expressions between the mapped type and the
interface type. The to expression converts from the
interface type to the mapped type and from converts
in the other direction. If no explicit conversion is required for
either direction, then the corresponding clause can be omitted.
The conversion expressions are regular expression substitutions.
They must contain the special (?) placeholder which will
be replaced with the actual value to be converted. Turning on SQL
statement tracing (Section 3.13, "Tracing SQL
Statement Execution") can be useful for debugging conversion
expressions. This allows you to see the substituted expressions
as used in the actual statements.

As an example, the following map pragma maps the
PostgreSQL array of INTEGER's to TEXT:


#pragma db map type("INTEGER *\\[(\\d*)\\]") \
as("TEXT") \
to("(?)::INTEGER[$1]") \
from("(?)::TEXT")


With the above mapping we can now have a persistent class that
has a member of the PostgreSQL array type:


#pragma db object
class object
{
...

#pragma db type("INTEGER[]")
std::string array_;
};


In PostgreSQL the array literal has the {n1,n2,...} form.
As a result, we need to make sure that we pass the correct text
representation in the array_ member, for example:


object o;
o.array_ = "{1,2,3}";
db.persist (o);


Of course, std::string is not the most natural
representation of an array of integers in C++. Instead,
std::vector<int> would have been much more
appropriate. To add support for mapping
std::vector<int> to PostgreSQL INTEGER[]
we need to provide a value_traits specialization
that implements conversion between the PostgreSQL text representation
of an array and std::vector<int>. Below is a sample
implementation:


namespace odb
{
namespace pgsql
{
template <>
class value_traits<std::vector<int>, id_string>
{
public:
typedef std::vector<int> value_type;
typedef value_type query_type;
typedef details::buffer image_type;

static void
set_value (value_type& v,
const details::buffer& b,
std::size_t n,
bool is_null)
{
v.clear ();

if (!is_null)
{
char c;
std::istringstream is (std::string (b.data (), n));

is >> c; // '{'

for (c = static_cast<char> (is.peek ()); c != '}'; is >> c)
{
v.push_back (int ());
is >> v.back ();
}
}
}

static void
set_image (details::buffer& b,
std::size_t& n,
bool& is_null,
const value_type& v)
{
is_null = false;
std::ostringstream os;

os << '{';

for (value_type::const_iterator i (v.begin ()), e (v.end ());
i != e;)
{
os << *i;

if (++i != e)
os << ',';
}

os << '}';

const std::string& s (os.str ());
n = s.size ();

if (n > b.capacity ())
b.capacity (n);

std::memcpy (b.data (), s.c_str (), n);
}
};
}
}


Once this specialization is included in the generated code (see
the mapping example in the odb-examples
package for details), we can use std::vector<int>
instead of std::string in our persistent class:


#pragma db object
class object
{
...

#pragma db type("INTEGER[]")
std::vector<int> array_;
};


If we wanted to always map std::vector<int>
to PostgreSQL INTEGER[], then we could instead
write:


typedef std::vector<int> int_vector;
#pragma db value(int_vector) type("INTEGER[]")

#pragma db object
class object
{
...

std::vector<int> array_; // Mapped to INTEGER[].
};


While the above example only shows how to handle PostgreSQL arrays,
other types in PostgreSQL and in other databases can be supported
in a similar way. The odb-tests package contains a
set of tests in the <database>/custom directories that,
for each database, shows how to provide custom mapping for some of
the extended types.

12.8 C++ Compiler Warnings

When a C++ header file defining persistent classes and containing
ODB pragmas is used to build the application, the C++ compiler may
issue warnings about pragmas that it doesn't recognize. There
are several ways to deal with this problem. The easiest is to
disable such warnings using one of the compiler-specific command
line options or warning control pragmas. This method is described
in the following sub-section for popular C++ compilers.

There are also several C++ compiler-independent methods that we
can employ. The first is to use the PRAGMA_DB macro,
defined in <odb/core.hxx>, instead of using
#pragma db directly. This macro expands to the
ODB pragma when compiled with the ODB compiler and to an empty
declaration when compiled with other compilers. The following example
shows how we can use this macro:


#include <odb/core.hxx>

PRAGMA_DB(object)
class person
{
...

PRAGMA_DB(id)
unsigned long id_;
};


An alternative to using the PRAGMA_DB macro is to
group the #pragma db directives in blocks that are
conditionally included into compilation only when compiled with the
ODB compiler. For example:


class person
{
...

unsigned long id_;
};

#ifdef ODB_COMPILER
# pragma db object(person)
# pragma db member(person::id_) id
#endif


The disadvantage of this approach is that it can quickly become
overly verbose when positioned pragmas are used.

12.8.1 GNU C++

GNU g++ does not issue warnings about unknown pragmas
unless requested with the -Wall command line option.
To disable only the unknown pragma warning, we can add the
-Wno-unknown-pragmas option after -Wall,
for example:


g++ -Wall -Wno-unknown-pragmas ...


12.8.2 Visual C++

Microsoft Visual C++ issues an unknown pragma warning (C4068) at
warning level 1 or higher. This means that unless we have disabled
the warnings altogether (level 0), we will see this warning.

To disable this warning via the compiler command line, we can add
the /wd4068 C++ compiler option in Visual Studio 2008
and earlier. In Visual Studio 2010 and later there is now a special
GUI field where we can enter warning numbers that should be disabled.
Simply enter 4068 into this field.

We can also disable this warning for only a specific header or
a fragment of a header using the warning control pragma. For
example:


#include <odb/core.hxx>

#pragma warning (push)
#pragma warning (disable:4068)

#pragma db object
class person
{
...

#pragma db id
unsigned long id_;
};

#pragma warning (pop)


12.8.3 Sun C++

The Sun C++ compiler does not issue warnings about unknown pragmas
unless the +w or +w2 option is specified.
To disable only the unknown pragma warning we can add the
-erroff=unknownpragma option anywhere on the
command line, for example:


CC +w -erroff=unknownpragma ...


12.8.4 IBM XL C++

IBM XL C++ issues an unknown pragma warning (1540-1401) by default.
To disable this warning we can add the -qsuppress=1540-1401
command line option, for example:


xlC -qsuppress=1540-1401 ...


12.8.5 HP aC++

HP aC++ (aCC) issues an unknown pragma warning (2161) by default.
To disable this warning we can add the +W2161
command line option, for example:


aCC +W2161 ...


12.8.6 Clang

Clang does not issue warnings about unknown pragmas
unless requested with the -Wall command line option.
To disable only the unknown pragma warning, we can add the
-Wno-unknown-pragmas option after -Wall,
for example:


clang++ -Wall -Wno-unknown-pragmas ...


We can also disable this warning for only a specific header or
a fragment of a header using the warning control pragma. For
example:


#include <odb/core.hxx>

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunknown-pragmas"

#pragma db object
class person
{
...

#pragma db id
unsigned long id_;
};

#pragma clang diagnostic pop







13 Advanced Techniques and Mechanisms

This chapter covers more advanced techniques and mechanisms
provided by ODB that may be useful in certain situations.

13.1 Transaction Callbacks

The ODB transaction class (odb::transaction) allows
an application to register a callback that will be called after
the transaction is finalized, that is, committed or rolled back.
This mechanism can be used, for example, to restore values that
were updated during the transaction execution to their original
states if the transaction is rolled back.

The callback management interface of the transaction
class is shown below.


namespace odb
{
class transaction
{
...

public:
static const unsigned short event_commit = 0x01;
static const unsigned short event_rollback = 0x02;
static const unsigned short event_all = event_commit | event_rollback;

typedef void (*callback_type) (
unsigned short event, void* key, unsigned long long data);

void
callback_register (callback_type callback,
void* key,
unsigned short event = event_all,
unsigned long long data = 0,
transaction** state = 0);


void
callback_unregister (void* key);

void
callback_update (void* key,
unsigned short event,
unsigned long long data = 0,
transaction** state = 0);
}
}


The callback_register() function registers a
post-commit/rollback callback. The callback
argument is the function that should be called. The
key argument is used by the transaction
to identify this callback. It is also normally used
to pass an address of the data object on which the
callback function will work. The event
argument is the bitwise-or of the events that should
trigger the callback.

The optional data argument can be used to store any POD
user data that doesn't exceed 8 bytes in size and doesn't require
alignment greater than unsigned long long. For
example, we could store an old value of a flag or a counter
that needs to be restored in case of a roll back.

The optional state argument can be used to
indicate that the callback has been unregistered because
the transaction was finalized. In this case the transaction
automatically resets the passed pointer to 0. This is
primarily useful if we are interested in only one of
the events (commit or rollback).

The callback_unregister() function unregisters a previously
registered callback. If the number of registered callbacks is
large, then this can be a slow operation. Generally, the callback
mechanism is optimized for cases where the callbacks stay
registered until the transaction is finalized.

Note also that you don't need to unregister a callback that has
been called or auto-reset using the state argument
passed to callback_register(). This function does nothing
if the key is not found.

The callback_update() function can be used to update
the event, data, and state
values of a previously registered callback. Similar to
callback_unregister(), this is a potentially slow
operation.

When the callback is called, it is passed the event that
triggered it, as well as the key and
data values that were passed to the
callback_register() function. Note also that the order
in which the callbacks are called is unspecified. The rollback
event can be triggered by an exception. In this case, if the
callback throws, the program will be terminated.

The following example shows how we can use transaction
callbacks together with database operation callbacks
(Section 12.1.7, "callback")
to manage the object's "dirty" flag.


#include <odb/callback.hxx>
#include <odb/transaction.hxx>

#pragma db object callback(update)
class object
{
...

#pragma db transient
mutable bool dirty_;

// Non-NULL value indicates that we are registered
// with this transaction.
//
#pragma db transient
mutable odb::transaction* tran_;

void
update (odb::callback_event e, odb::database&) const
{
using namespace odb::core;

if (e == callback_event::post_update)
return;

// Mark the object as clean again but register a
// transaction callback in case the update is rolled
// back.
//
tran_ = &transaction::current ();
tran_->callback_register (&rollback,
const_cast<object*> (this),
transaction::event_rollback,
0,
&tran_);
dirty_ = false;
}

static void
rollback (unsigned short, void* key, unsigned long long)
{
// Restore the dirty flag since the changes have been
// rolled back.
//
object& o (*static_cast<object*> (key));
o.dirty_ = true;
}

~object ()
{
// Unregister the callback if we are going away before
// the transaction.
//
if (tran_ != 0)
tran_->callback_unregister (this);
}
};







PART II
DATABASE SYSTEMS

Part II covers topics specific to the database system
implementations and their support in ODB. The first chapter in
Part II discusses how to use multiple database systems in the
same application. The subsequent chapters describe the system-specific
database classes as well as the default mapping
between basic C++ value types and native database types. Part
II consists of the following chapters.


14Multi-Database Support
15MySQL Database
16SQLite Database
17PostgreSQL Database
18Oracle Database
19Microsoft SQL Server Database







14 Multi-Database Support

Some applications may need to access multiple database systems, either
simultaneously or one at a time. For example, an application may
utilize an embedded database such as SQLite as a local cache and use
a client-server database such as PostgreSQL for more permanent
but slower to access remote storage. Or an application may need
to be able to store its data in any database selected at runtime
by the user. Yet another scenario is the data migration from one
database system to another. In this case, multi-database support
is only required for a short period. It is also plausible that an
application implements all three of these scenarios, that is, it
uses SQLite as a local cache, allows the user to select the remote
database system, and supports data migration from one remote database
system to another.

ODB provides two types of multi-database support: static
and dynamic. With static support we use the
database system-specific interfaces to perform database
operations. That is, instead of using odb::database,
odb::transaction, or odb::query, we
would use, for example, odb::sqlite::database,
odb::sqlite::transaction, or
odb::sqlite::query to access an SQLite database.

In contrast, with dynamic multi-database support we can
use the common interface to access any database without having to
know which one it is. At runtime, ODB will automatically dispatch
a call on the common interface to the specific database implementation
based on the actual database instance being
used. In fact, this mechanism is very similar to C++ virtual
functions.

Both static and dynamic multi-database support have a different set
of advantages and disadvantages which makes them more or less suitable
for different use cases. Static support has zero overhead compared
to single-database support and allows us to use database
system-specific features, extensions, etc. At the same time, the
code that we write will be tied to the specific database system.
As a result, this type of multi-database support is more
suitable for situations where different parts of an application
access different but specific database systems. For example,
using SQLite as a local cache most likely falls into this
category since we are using a specific database system (SQLite)
and the code that will check the cache will most likely (but
not necessarily) be separate from the code that interact with
the remote database. Another example where static multi-database
support might be more suitable is a once-off data migration from
one database system to another. In this case both the source and
target are specific database systems. In contrast, if data migration
from one database system to another is a general feature in an
application, then dynamic multi-database support might be more
suitable.

The main advantage of dynamic multi-database support is the
database system-independence of the code that we write. The same
application code will work with any database system supported by
ODB and the generated database support code can be packaged into
separate libraries and loaded dynamically by the application. The
disadvantages of dynamic support are slight overhead and certain
limitations in functionality compared to static support (see
Section 14.2, "Dynamic Multi-Database Support"
for details). As a result, dynamic multi-database support is most
suitable to situations where we need the same code to
work with a range of database systems. For example, if your
application must be able to store its data in any database
selected by the user, then dynamic support is probably the
best option.

Note also that it is possible to mix and match static and dynamic
support in the same application. In fact, dynamic support is built
on top of static support so it is possible to use the same database
system both "statically" and "dynamically". In particular, the ability
to "drop down" from dynamic to static support can be used to overcome
the functionality limitations mentioned above. Finally,
single-database support is just a special case of static
multi-database support with a single database system.

By default ODB assumes single-database support. To enable
multi-database support we use the --multi-database
(or -m) ODB compiler option. This option is also used to
specify the support type: static or dynamic.
For example:


odb -m static ... person.hxx


With multi-database support enabled, we can now generate the database
support code for several database systems. This can be accomplished
either with a single ODB compiler invocation by specifying multiple
--database (or -d) options or with multiple
ODB compiler invocations. Both approaches produce the same result,
for example:


odb -m static -d common -d sqlite -d pgsql person.hxx


Is equivalent to:


odb -m static -d common person.hxx
odb -m static -d sqlite person.hxx
odb -m static -d pgsql person.hxx


Notice that the first -d option has common
as its value. This is not a real database system. Rather, it instructs
the ODB compiler to generate code that is common to all the database
systems and, in case of dynamic support, is also the common
interfaces.

If you look at the result of the above commands, you will also notice
changes in the output file names. In the single-database mode the ODB
compiler produces a single set of the person-odb.?xx files
which contain both the common as well as the database specific
generated code (since there is only one database system in use,
there is no reason to split the two). In contrast, in the
multi-database mode, the person-odb.?xx set of files
contains the common code while the database system-specific code is
written to files in the form person-odb-<db>.?xx.
That is, person-odb-sqlite.?xx for SQLite,
person-odb-pgsql.?xx for PostgreSQL, etc.

If we need dynamic support for some databases and static for
others, then the common code must be generated
in the dynamic mode. For example, if we need static support
for SQLite and dynamic support for PostgreSQL and Oracle, then
the ODB compiler invocations could look like this:


odb -m dynamic -d common person.hxx
odb -m static -d sqlite person.hxx
odb -m dynamic -d pgsql person.hxx
odb -m dynamic -d oracle person.hxx


With multi-database support enabled, it is possible to restrict ODB
pragmas to apply only to a specific database system (unrestricted
pragmas apply to all the databases). For example:


#pragma db object
class person
{
...

#pragma db pgsql:type("VARCHAR(128)") sqlite:type("TEXT")
std::string name_;

unsigned short age_;

#pragma db pgsql index member(age_)
};


Above, the pragma for the name_ data member shows the
use of a database prefix (for example, pgsql:) that
only applies to the specifier that follows. The pragma that defines
an index on the age_ data member shows the use of a
database prefix that applies to the whole pragma. In this case the
database name must immediately follow the db keyword.


Similar to pragmas, ODB compiler options that determine the kind
(for example, --schema-format), names (for example,
--odb-file-suffix), or content (for example, prologue
and epilogue options) of the output files can be prefixed with the
database name. For example:


odb --odb-file-suffix common:-odb-common ...


Dynamic multi-database support requires consistent mapping across
all the databases. That is, the same classes and data members
should be mapped to objects, simple/composite values, etc., for
all the databases. In contrast, static multi-database support
does not have this restriction. Specifically, with static support,
some data members can be transient for some database systems.
Similarly, the same class (for example, point) can
be mapped to a simple value in one database (for example, to the
POINT PostgreSQL type) and to a composite value
in another (for example, in SQLite, which does not have a
built-in point type).

The following sections discuss static and dynamic multi-database
support in more detail.


14.1 Static Multi-Database Support

With static multi-database support, instead of including
person-odb.hxx, application source code has
to include person-odb-<db>.hxx header files
corresponding to the database systems that will be used.

The application code has to also use database system-specific
interfaces when performing database operations. As an example,
consider the following transaction in a single-database
application. It uses the common interfaces, that is, classes
from the odb namespace.


#include "person-odb.hxx"

odb::database& db = ...

typedef odb::query<person> query;
typedef odb::result<person> result;

odb::transaction t (db.begin ());
result r (db.query<person> (query::age < 30));
...
t.commit ();


In an application that employs static multi-database support
the same transaction for SQLite would be rewritten like this:


#include "person-odb-sqlite.hxx"

odb::sqlite::database& db = ...

typedef odb::sqlite::query<person> query;
typedef odb::result<person> result; // odb:: not odb::sqlite::

odb::sqlite::transaction t (db.begin ());
result r (db.query<person> (query::age < 30));
...
t.commit ();


That is, the database, transaction, and
query classes now come from the odb::sqlite
namespace instead of odb. Other classes that have
database system-specific interfaces are connection,
statement, and tracer. Note that
all of them derive from the corresponding common versions. It
is also possible to use common transaction,
connection, and statement classes
with static support, if desired.

Notice that we didn't use the odb::sqlite namespace
for the result class template. This is because
result is database system-independent. All other
classes defined in namespace odb, except those
specifically mentioned above, are database system-independent.
In particular, result, prepared_query,
session, schema_catalog, and all the
exceptions are database system-independent.

Writing odb::sqlite:: before every name can quickly
become burdensome. As we have seen before, in single-database
applications that use the common interface we can add the
using namespace directive to avoid qualifying
each name. For example:


#include "person-odb.hxx"

odb::database& db = ...

{
using namespace odb::core;

typedef query<person> person_query;
typedef result<person> person_result;

transaction t (db.begin ());
person_result r (db.query<person> (person_query::age < 30));
...
t.commit ();
}


A similar mechanism is available in multi-database support. Each
database runtime defines the odb::<db>::core
namespace that contains all the database system-independent
names as well as the database system-specific ones for this
database. Here is how we can rewire the above transaction
using this approach:


#include "person-odb-sqlite.hxx"

odb::sqlite::database& db = ...

{
using namespace odb::sqlite::core;

typedef query<person> person_query;
typedef result<person> person_result;

transaction t (db.begin ());
person_result r (db.query<person> (person_query::age < 30));
...
t.commit ();
}


If the using namespace directive cannot be used, for
example, because the same code fragment accesses several databases,
then we can still make the namespace qualifications more concise
by assigning shorter aliases to database namespaces. For example:


#include "person-odb-pgsql.hxx"
#include "person-odb-sqlite.hxx"

namespace pg = odb::pgsql;
namespace sl = odb::sqlite;

pg::database& pg_db = ...
sl::database& sl_db = ...

typedef pg::query<person> pg_query;
typedef sl::query<person> sl_query;
typedef odb::result<person> result;

// First check the local cache.
//
odb::transaction t (sl_db.begin ()); // Note: using common transaction.
result r (sl_db.query<person> (sl_query::age < 30));

// If no hits, try the remote database.
//
if (r.empty ())
{
t.commit (); // End the SQLite transaction.
t.reset (pg_db.begin ()); // Start the PostgreSQL transaction.

r = pg_db.query<person> (pg_query::age < 30);
}

// Handle the result.
//
...

t.commit ();


With static multi-database support we can make one of the databases
the default database with the --default-database option.
The default database can be accessed via the common interface, just
like with single-database support. For example:


odb -m static -d common -d pgsql -d sqlite --default-database pgsql ...


The default database mechanism can be useful when one of the
databases is primary or when retrofitting multi-database support
into an existing single-database application. For example, if
we are adding SQLite as a local cache into an existing
application that uses PostgreSQL as its only database, then
by making PostgreSQL the default database we avoid having to
change all the existing code. Note that if dynamic multi-database
support is enabled, then the common (dynamic) interface is always
made the default database.

14.2 Dynamic Multi-Database Support

With dynamic multi-database support, application source code only
needs to include the person-odb.hxx header file, just
like with single-database support. In particular, we don't need
to include any of the person-odb-<db>.hxx files
unless we would also like to use certain database systems in the
static multi-database mode.

When performing database operations, the application code
uses the common interfaces from the odb namespace,
just like with single-database support. As an example, consider
a function that can be used to load an object either from a local
SQLite cache or a remote PostgreSQL database (in reality, this
function can be used with any database system support by ODB
provided we generated the database support code for this database
and linked it into our application):


#include "person-odb.hxx"

std::unique_ptr<person>
load (odb::database& db, const std::string& name)
{
odb::transaction t (db.begin ());
std::unique_ptr<person> p (db.find (name));
t.commit ();
return p;
}

odb::pgsql::database& pg_db = ...
odb::sqlite::database& sl_db = ...

// First try the local cache.
//
std::unique_ptr<person> p (load (sl_db, "John Doe"));

// If not found, try the remote database.
//
if (p == 0)
p = load (pg_db, "John Doe");

...


As you can see, we can use dynamic multi-database support just like
single-database support except that now our code can work with
different database systems. Note, however, one difference: with
single-database support we could perform database operations using
either the common odb::database or a database system-specific
(for example, odb::sqlite::database) interface
with the same effect. In contrast, with dynamic multi-database support,
the use of the database system-specific interface results in the
switch to the static mode (for which, as was mentioned earlier, we would
need to include the corresponding person-odb-<db>.hxx
header file). As we will discuss shortly, switching from dynamic to
static mode can be used to overcome limitations imposed by dynamic
multi-database support.

Dynamic multi-database support has certain overheads and limitations
compared to static support. For database operations, the generated code
maintains function tables that are used to dispatch calls to the database
system-specific implementations. In single-database and static
multi-database support, the query type implements a thin
wrapper around the underlying database system's SELECT
statement. With dynamic multi-database support, because the
underlying database system is only known at query execution
(or preparation) time, the query type stores a
database system-independent representation of the query that
is then translated to the database system-specific form. Because
of this database system-independent representation, dynamic
support queries have a number of limitations. Specifically, dynamic
queries do not support parameter binding in native query fragments.
They also make copies of by-value parameterd (by-reference parameters
can be used to remove this overhead). Finally, parameters of array
types (for example, char[256]) can only be bound
by-reference.

As we mentioned earlier, switching from dynamic to static mode
can be an effective way to overcome these limitations. As an
example, consider a function that prints the list of people of
a certain age. The caller also specified the limit on the number
of entries to print. Some database systems, for example, PostgreSQL,
allow us to propagate this limit to the database server with the
LIMIT clause. To add this clause we would need to
construct a native query fragment and, as we discussed above, we
won't be able to bind a parameter (the limit) while in the dynamic
mode. The following implementation shows how we can overcome this
by switching to the static mode and using the PostgreSQL-specific
interface:


#include "person-odb.hxx"
#include "person-odb-pgsql.hxx" // Needed for static mode.

void
print (odb::database& db, unsigned short age, unsigned long limit)
{
typedef odb::query<person> query;
typedef odb::result<person> result;

odb::transaction t (db.begin ());

query q (query::age == age);
result r;

if (db.id () == odb::id_pgsql)
{
// We are using PostgreSQL. Drop down to the static mode and
// add the LIMIT clause to the query.
//
namespace pg = odb::pgsql;
typedef pg::query<person> pg_query;

pg::database& pg_db (static_cast<pg::database&> (db));
pg_query pg_q (pg_query (q) + "LIMIT" + pg_query::_val (limit));
r = pg_db.query<person> (pg_q);
}
else
r = db.query<person> (q);

// Handle the result up to the limit elements.
//
...

t.commit ();
}

odb::pgsql::database& pg_db = ...
odb::sqlite::database& sl_db = ...

print (sl_db, 30, 100);
print (sl_db, 30, 100);


A few things to note about this example. First, we use the
database::id() function to determine the actual database
system we use. This function has the following signature:


namespace odb
{
enum database_id
{
id_mysql,
id_sqlite,
id_pgsql,
id_oracle,
id_mssql,
id_common
};

class database
{
public:
...

database_id
id () const;
}
}


Note that database::id() can never return the
id_common value.

The other thing to note is how we translate the dynamic query
to the database system-specific one (the pg_query (q)
expression). Every odb::<db>::query class provides
such a translation constructor.

14.2.2 Dynamic Loading of Database Support Code

With dynamic multi-database support, the generated database support
code automatically registers itself with the function tables that
we mentioned earlier. This makes it possible to package the generated
code for each database into a separate dynamic-link library (Windows
DLL) or dynamic shared object (Unix DSO; collectively referred to as
DLLs from now on) and load/unload them from the application
dynamically using APIs such as Win32 LoadLibrary() or
POSIX dlopen(). This allows the application address
space to contain code only for database systems that are actually
needed in any particular moment. Another advantage of this approach
is the ability to distribute individual database system support
separately.

This section provides an overview of how to package the generated
database support code into DLLs for both Windows and Unix using
GNU/Linux as an example. Note also that if static multi-database
support is used for a particular database system, then the dynamic
loading cannot be used for this database. It is, however, still
possible to package the generated code into a DLL but this DLL
will have to be linked to the executable at link-time rather
than at runtime. If dynamic loading is desirable in this situation,
then another alternative would be to package the functionality
that requires static support together with the database support
code into the DLL and import this functionality dynamically
using the GetProcAddress() (Win32) or dlsym()
(Unix) function.

The first step in packaging the generated code into DLLs is to
set up the symbol exporting. This step is required for
Windows DLLs but is optional for Unix DSOs. Most modern Unix
systems (such as GNU/Linux) provide control over symbol
visibility, which is a mechanism similar to Windows symbol
exporting. Notable advantages of using this mechanism to
explicitly specify which symbols are visible include
smaller Unix DSOs and faster load times. If, however, you are
not planning to control symbol visibility on Unix, then you can
skip directly to the second step below.

An important point to understand is that we only need to export
the common interface, that is, the classes defined in the
person-odb.hxx header. In particular, we don't need
to export the database system-specific classes defined in
the person-odb-<db>.hxx, unless we are also using
this database in the static mode (in which case, the procedure
described below will need to be repeated for that database as
well).

The ODB compiler provides two command line options,
--export-symbol and --extern-symbol,
which can be used to insert the export and extern
macros in all the necessary places in the generated header file.
You are probably familiar with the concept of export macro which
expands to an export directive if we are building the DLL and to
an import directive if we are building client code. The
extern macro is a supplementary mechanism which is necessary to
export explicit template instantiations used by the generated
code when query support is enabled. As we will see shortly, the
extern macro must expand into the extern C++ keyword
in certain situations and must be left undefined in others. To
manage all these macro definitions, it is customary to create the
so called export header. Based on a single macro that is normally
defined in the project file or on the command line and which
indicates whether we are building the DLL or client code, the
export header file sets the export and extern macros to their
appropriate values. Continuing with our person example, on Windows
the export header, which we will call person-export.hxx,
could look like this:


// person-export.hxx
//
// Define PERSON_BUILD_DLL if we are building the DLL. Leave it
// undefined in client code.
//
#ifndef PERSON_EXPORT_HXX
#define PERSON_EXPORT_HXX

#ifdef PERSON_BUILD_DLL
# define PERSON_EXPORT __declspec(dllexport)
#else
# define PERSON_EXPORT __declspec(dllimport)
# define PERSON_EXTERN extern
#endif

#endif // PERSON_EXPORT_HXX


The equivalent export header for GCC on GNU/Linux is shown below.
Note also that on GNU/Linux, by default, all symbols are visible
and we need to add the GCC -fvisibility=hidden option to
make them hidden by default.


// person-export.hxx
//
#ifndef PERSON_EXPORT_HXX
#define PERSON_EXPORT_HXX

#define PERSON_EXPORT __attribute__ ((visibility ("default")))
#define PERSON_EXTERN extern

#endif // PERSON_EXPORT_HXX


Next we need to export the person persistent class
using the export macro and re-compile our person.hxx file
with the --export-symbol and --extern-symbol
options. We will also need to include person-export.hxx
into the generated person-odb.hxx file. For that we use
the --hxx-prologue option. Here is how we can do
this with multiple invocations of the ODB compiler:


odb -m dynamic -d common --hxx-prologue "#include \"person-export.hxx\"" \
--export-symbol PERSON_EXPORT --extern-symbol PERSON_EXTERN person.hxx

odb -m dynamic -d sqlite person.hxx
odb -m dynamic -d pgsql person.hxx


It is also possible to achieve the same with a single invocation.
Here we need to restrict some option values to apply only to the
common database:


odb -m dynamic -d common -d sqlite -d pgsql \
--hxx-prologue "common:#include \"person-export.hxx\"" \
--export-symbol common:PERSON_EXPORT --extern-symbol common:PERSON_EXTERN \
person.hxx


The second step in packaging the generated code into DLLs is to
decide where to place the generated common interface code. One
option is to place it into a DLL of its own so that we will end
up with (replace *.dll with lib*.so for
Unix): person.dll plus person-sqlite.dll and
person-pgsql.dll, which both link to person.dll,
as well as person.exe, which links to person.dll
and dynamically loads person-sqlite.dll
and/or person-pgsql.dll. If this is the organization
that you prefer, then the next step is to build all the DLLs as you
normally would any other DLL, placing person-odb.cxx
and person.cxx into person.dll,
person-odb-sqlite.cxx into person-sqlite.dll,
etc. Note that in the pure dynamic multi-database support,
person-sqlite.dll and person-pgsql.dll
do not export any symbols.

We can improve on the above organization by getting rid of
person.dll, which is not really necessary unless
we have multiple executables sharing the same database support.
To achieve this, we will place person-odb.cxx into
person.exe and export its symbols from the executable
instead of a DLL. Exporting symbols from an executable is a seldom
used functionality, especially on Windows, however, it is well
supported on both Windows and most Unix platforms. Note also that
this approach won't work if we also use one of the databases in the
static mode.

On Windows all we have to do is place person-odb.cxx
into the executable and compile it as we would in a DLL (that is,
with the PERSON_BUILD_DLL macro defined). If Windows
linker detects that an executable exports any symbols, then it
will automatically create the corresponding import library
(person.lib in our case). We then use this import
library to build person-sqlite.dll and
person-pgsql.dll as before.

To export symbols from an executable on GNU/Linux all we need to
do is add the -rdynamic option when linking our
executable.





15 MySQL Database

To generate support code for the MySQL database you will need
to pass the "--database mysql"
(or "-d mysql") option to the ODB compiler.
Your application will also need to link to the MySQL ODB runtime
library (libodb-mysql). All MySQL-specific ODB
classes are defined in the odb::mysql namespace.

15.1 MySQL Type Mapping

The following table summarizes the default mapping between basic
C++ value types and MySQL database types. This mapping can be
customized on the per-type and per-member basis using the ODB
Pragma Language (Chapter 12, "ODB Pragma
Language").




C++ Type
MySQL Type
Default NULL Semantics



bool
TINYINT(1)
NOT NULL



char
CHAR(1)
NOT NULL



signed char
TINYINT
NOT NULL



unsigned char
TINYINT UNSIGNED
NOT NULL



short
SMALLINT
NOT NULL



unsigned short
SMALLINT UNSIGNED
NOT NULL



int
INT
NOT NULL



unsigned int
INT UNSIGNED
NOT NULL



long
BIGINT
NOT NULL



unsigned long
BIGINT UNSIGNED
NOT NULL



long long
BIGINT
NOT NULL



unsigned long long
BIGINT UNSIGNED
NOT NULL



float
FLOAT
NOT NULL



double
DOUBLE
NOT NULL



std::string
TEXT/VARCHAR(255)
NOT NULL



char[N]
VARCHAR(N-1)
NOT NULL



It is possible to map the char C++ type to an integer
database type (for example, TINYINT) using the
db type pragma (Section 12.4.3,
"type").

Note that the std::string type is mapped
differently depending on whether a member of this type
is an object id or not. If the member is an object id,
then for this member std::string is mapped
to the VARCHAR(255) MySQL type. Otherwise,
it is mapped to TEXT.

Additionally, by default, C++ enumerations are automatically
mapped to a suitable MySQL type. Contiguous enumerations with
the zero first enumerator are mapped to the MySQL ENUM
type. All other enumerations are mapped to INT or
INT UNSIGNED. In both cases the default NULL
semantics is NOT NULL. For example:


enum color {red, green, blue};
enum taste
{
bitter = 1, // Non-zero first enumerator.
sweet,
sour = 4, // Non-contiguous.
salty
};

#pragma db object
class object
{
...

color color_; // Mapped to ENUM ('red', 'green', 'blue') NOT NULL.
taste taste_; // Mapped to INT UNSIGNED NOT NULL.
};


It is also possible to add support for additional MySQL types,
such as geospatial types. For more information, refer to
Section 12.7, "Database Type Mapping
Pragmas".

15.1.1 String Type Mapping

The MySQL ODB runtime library provides support for mapping the
std::string, char[N], and
std::array<char, N> types to the MySQL CHAR,
VARCHAR, TEXT, NCHAR, and
NVARCHAR types. However, these mappings are not enabled
by default (in particular, by default, std::array will
be treated as a container). To enable the alternative mappings for
these types we need to specify the database type explicitly using
the db type pragma (Section
12.4.3, "type"), for example:


#pragma db object
class object
{
...

#pragma db type("CHAR(2)")
char state_[2];

#pragma db type("VARCHAR(128)")
std::string name_;
};


Alternatively, this can be done on the per-type basis, for example:


#pragma db value(std::string) type("VARCHAR(128)")

#pragma db object
class object
{
...

std::string name_; // Mapped to VARCHAR(128).
};


The char[N] and std::array<char, N> values
may or may not be zero-terminated. When extracting such values from the
database, ODB will append the zero terminator if there is enough
space.

15.1.2 Binary Type Mapping

The MySQL ODB runtime library provides support for mapping the
std::vector<char>,
std::vector<unsigned char>,
char[N], unsigned char[N],
std::array<char, N>, and
std::array<unsigned char, N>
types to the MySQL BINARY, VARBINARY,
and BLOB types. However, these mappings are not enabled
by default (in particular, by default, std::vector and
std::array will be treated as containers). To enable the
alternative mappings for these types we need to specify the database
type explicitly using the db type pragma
(Section 12.4.3, "type"), for
example:


#pragma db object
class object
{
...

#pragma db type("BLOB")
std::vector<char> buf_;

#pragma db type("BINARY(16)")
unsigned char uuid_[16];
};


Alternatively, this can be done on the per-type basis, for example:


typedef std::vector<char> buffer;
#pragma db value(buffer) type("BLOB")

#pragma db object
class object
{
...

buffer buf_; // Mapped to BLOB.
};


Note also that in native queries (Chapter 4, "Querying
the Database") char[N] and
std::array<char, N> parameters are by default passed
as a string rather than a binary. To pass such parameters as a binary,
we need to specify the database type explicitly in the
_val()/_ref() calls. Note also that we
don't need to do this for the integrated queries, for example:


char u[16] = {...};

db.query<object> ("uuid = " + query::_val<odb::mysql::id_blob> (u));
db.query<object> (query::uuid == query::_ref (u));


15.2 MySQL Database Class

The MySQL database class has the following
interface:


namespace odb
{
namespace mysql
{
class database: public odb::database
{
public:
database (const char* user,
const char* passwd,
const char* db,
const char* host = 0,
unsigned int port = 0,
const char* socket = 0,
const char* charset = 0,
unsigned long client_flags = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string& passwd,
const std::string& db,
const std::string& host = "",
unsigned int port = 0,
const std::string* socket = 0,
const std::string& charset = "",
unsigned long client_flags = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string* passwd,
const std::string& db,
const std::string& host = "",
unsigned int port = 0,
const std::string* socket = 0,
const std::string& charset = "",
unsigned long client_flags = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string& passwd,
const std::string& db,
const std::string& host,
unsigned int port,
const std::string& socket,
const std::string& charset = "",
unsigned long client_flags = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string* passwd,
const std::string& db,
const std::string& host,
unsigned int port,
const std::string& socket,
const std::string& charset = "",
unsigned long client_flags = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (int& argc,
char* argv[],
bool erase = false,
const std::string& charset = "",
unsigned long client_flags = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

static void
print_usage (std::ostream&);

public:
const char*
user () const;

const char*
password () const;

const char*
db () const;

const char*
host () const;

unsigned int
port () const;

const char*
socket () const;

const char*
charset () const;

unsigned long
client_flags () const;

public:
connection_ptr
connection ();
};
}
}


You will need to include the <odb/mysql/database.hxx>
header file to make this class available in your application.

The overloaded database constructors allow us
to specify MySQL database parameters that should be used when
connecting to the database. In MySQL NULL and an
empty string are treated as the same values for all the
string parameters except password and
socket.

The charset argument allows us to specify the client
character set, that is, the character set in which the application
will encode its text data. Note that this can be different from
the MySQL server character set. If this argument is not specified or
is empty, then the default MySQL client character set is used, normally
latin1. Commonly used values for this argument are
latin1 (equivalent to Windows cp1252 and similar to
ISO-8859-1) and utf8. For other possible values
as well as more information on character set support in MySQL,
refer to the MySQL documentation.

The client_flags argument allows us to specify various
MySQL client library flags. For more information on the possible
values, refer to the MySQL C API documentation. The
CLIENT_FOUND_ROWS flag is always set by the MySQL ODB
runtime regardless of whether it was passed in the
client_flags argument.

The last constructor extracts the database parameters
from the command line. The following options are recognized:


--user <login>
--password <password>
--database <name>
--host <host>
--port <integer>
--socket <socket>
--options-file <file>


The --options-file option allows us to specify some
or all of the database options in a file with each option appearing
on a separate line followed by a space and an option value.

If the erase argument to this constructor is true,
then the above options are removed from the argv
array and the argc count is updated accordingly.
This is primarily useful if your application accepts other
options or arguments and you would like to get the MySQL
options out of the argv array.

This constructor throws the odb::mysql::cli_exception
exception if the MySQL option values are missing or invalid.
See section Section 15.4, "MySQL Exceptions"
for more information on this exception.

The static print_usage() function prints the list of options
with short descriptions that are recognized by this constructor.

The last argument to all of the constructors is a pointer to the
connection factory. In C++98/03, it is std::auto_ptr while
in C++11 std::unique_ptr is used instead. If we pass a
non-NULL value, the database instance assumes ownership
of the factory instance. The connection factory interface as well as
the available implementations are described in the next section.

The set of accessor functions following the constructors allows us
to query the parameters of the database instance.

The connection() function returns a pointer to the
MySQL database connection encapsulated by the
odb::mysql::connection class. For more information
on mysql::connection, refer to Section
15.3, "MySQL Connection and Connection Factory".

15.3 MySQL Connection and Connection Factory

The mysql::connection class has the following interface:


namespace odb
{
namespace mysql
{
class connection: public odb::connection
{
public:
connection (database&);
connection (database&, MYSQL*);

MYSQL*
handle ();
};

typedef details::shared_ptr<connection> connection_ptr;
}
}


For more information on the odb::connection interface,
refer to Section 3.6, "Connections". The first
overloaded mysql::connection constructor establishes a
new MySQL connection. The second constructor allows us to create
a connection instance by providing an already connected
native MySQL handle. Note that the connection
instance assumes ownership of this handle. The handle()
accessor returns the MySQL handle corresponding to the connection.

The mysql::connection_factory abstract class has the
following interface:


namespace odb
{
namespace mysql
{
class connection_factory
{
public:
virtual void
database (database&) = 0;

virtual connection_ptr
connect () = 0;
};
}
}


The database() function is called when a connection
factory is associated with a database instance. This happens in
the odb::mysql::database class constructors. The
connect() function is called whenever a database
connection is requested.

The two implementations of the connection_factory
interface provided by the MySQL ODB runtime are
new_connection_factory and
connection_pool_factory. You will need to include
the <odb/mysql/connection-factory.hxx>
header file to make the connection_factory interface
and these implementation classes available in your application.

The new_connection_factory class creates a new
connection whenever one is requested. When a connection is no
longer needed, it is released and closed. The
new_connection_factory class has the following
interface:


namespace odb
{
namespace mysql
{
class new_connection_factory: public connection_factory
{
public:
new_connection_factory ();
};
};


The connection_pool_factory class implements a
connection pool. It has the following interface:


namespace odb
{
namespace mysql
{
class connection_pool_factory: public connection_factory
{
public:
connection_pool_factory (std::size_t max_connections = 0,
std::size_t min_connections = 0,
bool ping = true);

protected:
class pooled_connection: public connection
{
public:
pooled_connection (database_type&);
pooled_connection (database_type&, MYSQL*);
};

typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;

virtual pooled_connection_ptr
create ();
};
};


The max_connections argument in the
connection_pool_factory constructor specifies the maximum
number of concurrent connections that this pool factory will
maintain. Similarly, the min_connections argument
specifies the minimum number of available connections that
should be kept open. The ping argument specifies
whether the factory should validate the connection before
returning it to the caller.

Whenever a connection is requested, the pool factory first
checks if there is an unused connection that can be returned.
If there is none, the pool factory checks the
max_connections value to see if a new connection
can be created. If the total number of connections maintained
by the pool is less than this value, then a new connection is
created and returned. Otherwise, the caller is blocked until
a connection becomes available.

When a connection is released, the pool factory first checks
if there are blocked callers waiting for a connection. If so, then
one of them is unblocked and is given the connection. Otherwise,
the pool factory checks whether the total number of connections
maintained by the pool is greater than the min_connections
value. If that's the case, the connection is closed. Otherwise, the
connection is added to the pool of available connections to be
returned on the next request. In other words, if the number of
connections maintained by the pool exceeds min_connections
and there are no callers waiting for a new connection,
then the pool will close the excess connections.

If the max_connections value is 0, then the pool will
create a new connection whenever all of the existing connections
are in use. If the min_connections value is 0, then
the pool will never close a connection and instead maintain all
the connections that were ever created.

Connection validation (the ping argument) is useful
if your application may experience long periods of inactivity. In
such cases the MySQL server may close network connections that have
been inactive for too long. If during connection validation the pool
factory detects that the connection has been terminated, it silently
closes it and tries to find or create another connection instead.

The create() virtual function is called whenever the
pool needs to create a new connection. By deriving from the
connection_pool_factory class and overriding this
function we can implement custom connection establishment
and configuration.

If you pass NULL as the connection factory to
one of the database constructors, then the
connection_pool_factory instance will be
created by default with the min and max connections values
set to 0 and connection validation enabled.
The following code fragment shows how we can pass our own
connection factory instance:


#include <odb/database.hxx>

#include <odb/mysql/database.hxx>
#include <odb/mysql/connection-factory.hxx>

int
main (int argc, char* argv[])
{
auto_ptr<odb::mysql::connection_factory> f (
new odb::mysql::connection_pool_factory (20));

auto_ptr<odb::database> db (
new mysql::database (argc, argv, false, 0, f));
}


15.4 MySQL Exceptions

The MySQL ODB runtime library defines the following MySQL-specific
exceptions:


namespace odb
{
namespace mysql
{
class database_exception: odb::database_exception
{
public:
unsigned int
error () const;

const std::string&
sqlstate () const;

const std::string&
message () const;

virtual const char*
what () const throw ();
};

class cli_exception: odb::exception
{
public:
virtual const char*
what () const throw ();
};
}
}


You will need to include the <odb/mysql/exceptions.hxx>
header file to make these exceptions available in your application.

The odb::mysql::database_exception is thrown if
a MySQL database operation fails. The MySQL-specific error
information is accessible via the error(),
sqlstate(), and message() functions.
All this information is also combined and returned in a
human-readable form by the what() function.

The odb::mysql::cli_exception is thrown by the
command line parsing constructor of the odb::mysql::database
class if the MySQL option values are missing or invalid. The
what() function returns a human-readable description
of an error.

15.5 MySQL Limitations

The following sections describe MySQL-specific limitations imposed
by the current MySQL and ODB runtime versions.

15.5.1 Foreign Key Constraints

ODB relies on standard SQL behavior which requires that foreign
key constraints checking is deferred until the transaction is
committed. The only behaviors supported by MySQL are to either
check such constraints immediately (InnoDB engine) or to ignore
foreign key constraints altogether (all other engines). As a
result, schemas generated by the ODB compiler for MySQL have
foreign key definitions commented out. They are retained only
for documentation.

15.6 MySQL Index Definitions

When the index pragma (Section 12.6,
"Index Definition Pragmas") is used to define a MySQL index,
the type clause specifies the index type (for example,
UNIQUE, FULLTEXT, SPATIAL),
the method clause specifies the index method (for
example, BTREE, HASH), and the
options clause is not used. The column options
can be used to specify column length limits and the sort order.
For example:


#pragma db object
class object
{
...

std::string name_;

#pragma db index method("HASH") member(name_, "(100) DESC")
};







16 SQLite Database

To generate support code for the SQLite database you will need
to pass the "--database sqlite"
(or "-d sqlite") option to the ODB compiler.
Your application will also need to link to the SQLite ODB runtime
library (libodb-sqlite). All SQLite-specific ODB
classes are defined in the odb::sqlite namespace.

16.1 SQLite Type Mapping

The following table summarizes the default mapping between basic
C++ value types and SQLite database types. This mapping can be
customized on the per-type and per-member basis using the ODB
Pragma Language (Chapter 12, "ODB Pragma
Language").




C++ Type
SQLite Type
Default NULL Semantics



bool
INTEGER
NOT NULL



char
TEXT
NOT NULL



signed char
INTEGER
NOT NULL



unsigned char
INTEGER
NOT NULL



short
INTEGER
NOT NULL



unsigned short
INTEGER
NOT NULL



int
INTEGER
NOT NULL



unsigned int
INTEGER
NOT NULL



long
INTEGER
NOT NULL



unsigned long
INTEGER
NOT NULL



long long
INTEGER
NOT NULL



unsigned long long
INTEGER
NOT NULL



float
REAL
NULL



double
REAL
NULL



std::string
TEXT
NOT NULL



char[N]
TEXT
NOT NULL



std::wstring (Windows only)
TEXT
NOT NULL



wchar_t[N] (Windows only)
TEXT
NOT NULL



It is possible to map the char C++ type to the
INTEGER SQLite type (TINYINT) using
the db type pragma (Section
12.4.3, "type").

SQLite represents the NaN FLOAT value
as a NULL value. As a result, columns of the
float and double types are by default
declared as NULL. However, you can override this by
explicitly declaring them as NOT NULL with the
db not_null pragma (Section
12.4.6, "null/not_null").

Additionally, by default, C++ enumerations are automatically mapped to
the SQLite INTEGER type with the default NULL
semantics being NOT NULL.

Note also that SQLite only operates with signed integers and the largest
value that an SQLite database can store is a signed 64-bit integer. As
a result, greater unsigned long and
unsigned long long values will be represented in
the database as negative values.

It is also possible to add support for additional SQLite types,
such as NUMERIC. For more information, refer to
Section 12.7, "Database Type Mapping
Pragmas".

16.1.1 String Type Mapping

The SQLite ODB runtime library provides support for mapping the
std::array<char, N> and, on Windows,
std::array<wchar_t, N> types to the SQLite
TEXT type. However, this mapping is not enabled by
default (in particular, by default, std::array will
be treated as a container). To enable the alternative mapping for
this type we need to specify the database type explicitly using
the db type pragma (Section
12.4.3, "type"), for example:


#pragma db object
class object
{
...

#pragma db type("TEXT")
std::array<char, 128> name_;
};


Alternatively, this can be done on the per-type basis, for example:


typedef std::array<char, 128> name_type;
#pragma db value(name_type) type("TEXT")

#pragma db object
class object
{
...

name_type name_; // Mapped to TEXT.
};


The char[N], std::array<char, N>,
wchar_t[N], and std::array<wchar_t, N>
values may or may not be zero-terminated. When extracting such values
from the database, ODB will append the zero terminator if there is
enough space.

16.1.2 Binary Type Mapping

The SQLite ODB runtime library provides support for mapping the
std::vector<char>,
std::vector<unsigned char>,
char[N], unsigned char[N],
std::array<char, N>, and
std::array<unsigned char, N>
types to the SQLite BLOB type. However, these mappings
are not enabled by default (in particular, by default,
std::vector and std::array will be treated
as containers). To enable the alternative mappings for these types
we need to specify the database type explicitly using the
db type pragma (Section 12.4.3,
"type"), for example:


#pragma db object
class object
{
...

#pragma db type("BLOB")
std::vector<char> buf_;

#pragma db type("BLOB")
unsigned char uuid_[16];
};


Alternatively, this can be done on the per-type basis, for example:


typedef std::vector<char> buffer;
#pragma db value(buffer) type("BLOB")

#pragma db object
class object
{
...

buffer buf_; // Mapped to BLOB.
};


Note also that in native queries (Chapter 4, "Querying
the Database") char[N] and
std::array<char, N> parameters are by default passed
as a string rather than a binary. To pass such parameters as a binary,
we need to specify the database type explicitly in the
_val()/_ref() calls. Note also that we
don't need to do this for the integrated queries, for example:


char u[16] = {...};

db.query<object> ("uuid = " + query::_val<odb::sqlite::id_blob> (u));
db.query<object> (query::uuid == query::_ref (u));


16.2 SQLite Database Class

The SQLite database class has the following
interface:


namespace odb
{
namespace sqlite
{
class database: public odb::database
{
public:
database (const std::string& name,
int flags = SQLITE_OPEN_READWRITE,
bool foreign_keys = true,
const std::string& vfs = "",
std::[auto|unique]_ptr<connection_factory> = 0);

#ifdef _WIN32
database (const std::wstring& name,
int flags = SQLITE_OPEN_READWRITE,
bool foreign_keys = true,
const std::string& vfs = "",
std::[auto|unique]_ptr<connection_factory> = 0);
#endif

database (int& argc,
char* argv[],
bool erase = false,
int flags = SQLITE_OPEN_READWRITE,
bool foreign_keys = true,
const std::string& vfs = "",
std::[auto|unique]_ptr<connection_factory> = 0);

static void
print_usage (std::ostream&);

public:
const std::string&
name () const;

int
flags () const;

public:
transaction
begin_immediate ();

transaction
begin_exclusive ();

public:
connection_ptr
connection ();
};
}
}


You will need to include the <odb/sqlite/database.hxx>
header file to make this class available in your application.

The first constructor opens the specified SQLite database. The
name argument is the database file name to open in
the UTF-8 encoding. If this argument is empty, then a temporary,
on-disk database is created. If this argument is the
:memory: special value, then a temporary, in-memory
database is created. The flags argument allows us to
specify SQLite opening flags. For more information on the possible
values, refer to the sqlite3_open_v2() function description
in the SQLite C API documentation. The foreign_keys
argument specifies whether foreign key constraints checking
should be enabled. See Section 16.5.3,
"Foreign Key Constraints" for more information on foreign
keys. The vfs argument specifies the SQLite
virtual file system module that should be used to access the
database. If this argument is empty, then the default vfs module
is used. Again, refer to the sqlite3_open_v2() function
documentation for detail.

The following example shows how we can open the test.db
database in the read-write mode and create it if it does not exist:


auto_ptr<odb::database> db (
new odb::sqlite::database (
"test.db",
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));


The second constructor is the same as the first except that the database
name is passes as std::wstring in the UTF-16 encoding. This
constructor is only available when compiling for Windows.

The third constructor extracts the database parameters from the
command line. The following options are recognized:


--database <name>
--create
--read-only
--options-file <file>


By default, this constructor opens the database in the read-write mode
(SQLITE_OPEN_READWRITE flag). If the --create
flag is specified, then the database file is created if it does
not already exist (SQLITE_OPEN_CREATE flag). If the
--read-only flag is specified, then the database is
opened in the read-only mode (SQLITE_OPEN_READONLY
flag instead of SQLITE_OPEN_READWRITE). The
--options-file option allows us to specify some
or all of the database options in a file with each option appearing
on a separate line followed by a space and an option value.

If the erase argument to this constructor is true,
then the above options are removed from the argv
array and the argc count is updated accordingly.
This is primarily useful if your application accepts other
options or arguments and you would like to get the SQLite
options out of the argv array.

The flags argument has the same semantics as in
the first constructor. Flags from the command line always override
the corresponding values specified with this argument.

The third constructor throws the odb::sqlite::cli_exception
exception if the SQLite option values are missing or invalid.
See Section 16.4, "SQLite Exceptions"
for more information on this exception.

The static print_usage() function prints the list of options
with short descriptions that are recognized by the third constructor.

The last argument to all of the constructors is a pointer to the
connection factory. In C++98/03, it is std::auto_ptr while
in C++11 std::unique_ptr is used instead. If we pass a
non-NULL value, the database instance assumes ownership
of the factory instance. The connection factory interface as well as
the available implementations are described in the next section.

The set of accessor functions following the constructors allows us
to query the parameters of the database instance.

The begin_immediate() and begin_exclusive()
functions are the SQLite-specific extensions to the standard
odb::database::begin() function (see
Section 3.5, "Transactions"). They allow us
to start an immediate (BEGIN IMMEDIATE) and an exclusive
(BEGIN EXCLUSIVE) SQLite transaction, respectively.
For more information on the semantics of the immediate and exclusive
transactions, refer to the BEGIN statement description
in the SQLite documentation.

The connection() function returns a pointer to the
SQLite database connection encapsulated by the
odb::sqlite::connection class. For more information
on sqlite::connection, refer to Section
16.3, "SQLite Connection and Connection Factory".

16.3 SQLite Connection and Connection Factory

The sqlite::connection class has the following interface:


namespace odb
{
namespace sqlite
{
class connection: public odb::connection
{
public:
connection (database&, int extra_flags = 0);
connection (database&, sqlite3*);

transaction
begin_immediate ();

transaction
begin_exclusive ();

sqlite3*
handle ();
};

typedef details::shared_ptr<connection> connection_ptr;
}
}


For more information on the odb::connection interface,
refer to Section 3.6, "Connections". The first
overloaded sqlite::connection constructor opens
a new SQLite connection. The extra_flags argument can
be used to specify extra sqlite3_open_v2() flags
that are combined with the flags specified in the
sqlite::database constructor. The second constructor
allows us to create a connection instance by providing
an already open native SQLite handle. Note that the
connection instance assumes ownership of this handle.

The begin_immediate() and begin_exclusive()
functions allow us to start an immediate and an exclusive SQLite
transaction on the connection, respectively. Their semantics are
equivalent to the corresponding functions defined in the
sqlite::database class (Section 16.2,
"SQLite Database Class"). The handle() accessor
returns the SQLite handle corresponding to the connection.

The sqlite::connection_factory abstract class has the
following interface:


namespace odb
{
namespace sqlite
{
class connection_factory
{
public:
virtual void
database (database&) = 0;

virtual connection_ptr
connect () = 0;
};
}
}


The database() function is called when a connection
factory is associated with a database instance. This happens in
the odb::sqlite::database class constructors. The
connect() function is called whenever a database
connection is requested.

The three implementations of the connection_factory
interface provided by the SQLite ODB runtime library are
single_connection_factory,
new_connection_factory, and
connection_pool_factory. You will need to include
the <odb/sqlite/connection-factory.hxx>
header file to make the connection_factory interface
and these implementation classes available in your application.

The single_connection_factory class creates a
single connection that is shared between all the threads in
an application. If the connection is currently not in use,
then it is returned to the caller. Otherwise, the caller is
blocked until the connection becomes available. The
single_connection_factory class has the following
interface:


namespace odb
{
namespace sqlite
{
class single_connection_factory: public connection_factory
{
public:
single_connection_factory ();

protected:
class single_connection: public connection
{
public:
single_connection (database_type&);
single_connection (database_type&, MYSQL*);
};

typedef details::shared_ptr<single_connection> single_connection_ptr;

virtual single_connection_ptr
create ();
};
};


The create() virtual function is called when the
factory needs to create the connection. By deriving from the
single_connection_factory class and overriding this
function we can implement custom connection establishment
and configuration.

The new_connection_factory class creates a new
connection whenever one is requested. When a connection is no
longer needed, it is released and closed. The
new_connection_factory class has the following
interface:


namespace odb
{
namespace sqlite
{
class new_connection_factory: public connection_factory
{
public:
new_connection_factory ();
};
};


The connection_pool_factory class implements a
connection pool. It has the following interface:


namespace odb
{
namespace sqlite
{
class connection_pool_factory: public connection_factory
{
public:
connection_pool_factory (std::size_t max_connections = 0,
std::size_t min_connections = 0);

protected:
class pooled_connection: public connection
{
public:
pooled_connection (database_type&, int extra_flags = 0);
pooled_connection (database_type&, sqlite3*);
};

typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;

virtual pooled_connection_ptr
create ();
};
};


The max_connections argument in the
connection_pool_factory constructor specifies the maximum
number of concurrent connections that this pool factory will
maintain. Similarly, the min_connections argument
specifies the minimum number of available connections that
should be kept open.

Whenever a connection is requested, the pool factory first
checks if there is an unused connection that can be returned.
If there is none, the pool factory checks the
max_connections value to see if a new connection
can be created. If the total number of connections maintained
by the pool is less than this value, then a new connection is
created and returned. Otherwise, the caller is blocked until
a connection becomes available.

When a connection is released, the pool factory first checks
if there are blocked callers waiting for a connection. If so, then
one of them is unblocked and is given the connection. Otherwise,
the pool factory checks whether the total number of connections
maintained by the pool is greater than the min_connections
value. If that's the case, the connection is closed. Otherwise, the
connection is added to the pool of available connections to be
returned on the next request. In other words, if the number of
connections maintained by the pool exceeds min_connections
and there are no callers waiting for a new connection,
then the pool will close the excess connections.

If the max_connections value is 0, then the pool will
create a new connection whenever all of the existing connections
are in use. If the min_connections value is 0, then
the pool will never close a connection and instead maintain all
the connections that were ever created.

The create() virtual function is called whenever the
pool needs to create a new connection. By deriving from the
connection_pool_factory class and overriding this
function we can implement custom connection establishment
and configuration.

By default, connections created by new_connection_factory
and connection_pool_factory enable the SQLite shared cache
mode and use the unlock notify functionality to aid concurrency. To
disable the shared cache mode you can pass the
SQLITE_OPEN_PRIVATECACHE flag when creating the database
instance. For more information on the shared cache mode refer to the
SQLite documentation.

If you pass NULL as the connection factory to one of the
database constructors, then the connection_pool_factory
instance will be created by default with the min and max connections
values set to 0. The following code fragment shows how we
can pass our own connection factory instance:


#include <odb/database.hxx>

#include <odb/sqlite/database.hxx>
#include <odb/sqlite/connection-factory.hxx>

int
main (int argc, char* argv[])
{
auto_ptr<odb::sqlite::connection_factory> f (
new odb::sqlite::connection_pool_factory (20));

auto_ptr<odb::database> db (
new sqlite::database (argc, argv, false, SQLITE_OPEN_READWRITE, f));
}


16.4 SQLite Exceptions

The SQLite ODB runtime library defines the following SQLite-specific
exceptions:


namespace odb
{
namespace sqlite
{
class database_exception: odb::database_exception
{
public:
int
error () const

int
extended_error () const;

const std::string&
message () const;

virtual const char*
what () const throw ();
};

class cli_exception: odb::exception
{
public:
virtual const char*
what () const throw ();
};
}
}


You will need to include the <odb/sqlite/exceptions.hxx>
header file to make these exceptions available in your application.

The odb::sqlite::database_exception is thrown if
an SQLite database operation fails. The SQLite-specific error
information is accessible via the error(),
extended_error(), and message() functions.
All this information is also combined and returned in a
human-readable form by the what() function.

The odb::sqlite::cli_exception is thrown by the
command line parsing constructor of the odb::sqlite::database
class if the SQLite option values are missing or invalid. The
what() function returns a human-readable description
of an error.


16.5 SQLite Limitations

The following sections describe SQLite-specific limitations imposed by
the current SQLite and ODB runtime versions.

16.5.1 Query Result Caching

SQLite ODB runtime implementation does not perform query result caching
(Section 4.4, "Query Result") even when explicitly
requested. The SQLite API supports interleaving execution of multiple
prepared statements on a single connection. As a result, with SQLite, it
is possible to have multiple uncached results and calls to other database
functions do not invalidate them. The only limitation of the uncached
SQLite results is the unavailability of the result::size()
function. If you call this function on an SQLite query result, then
the odb::result_not_cached exception
(Section 3.14, "ODB Exceptions") is always
thrown. Future versions of the SQLite ODB runtime library may add support
for result caching.

16.5.2 Automatic Assignment of Object Ids

Due to SQLite API limitations, every automatically assigned object id
(Section 12.4.2, "auto") should have
the INTEGER SQLite type. While SQLite will treat other
integer type names (such as INT, BIGINT, etc.)
as INTEGER, automatic id assignment will not work. By default,
ODB maps all C++ integral types to INTEGER. This means that
the only situation that requires consideration is the assignment of a
custom database type using the db type pragma
(Section 12.4.3, "type"). For
example:


#pragma db object
class person
{
...

//#pragma db id auto type("INT") // Will not work.
//#pragma db id auto type("INTEGER") // Ok.
#pragma db id auto // Ok, Mapped to INTEGER.
unsigned int id_;
};


16.5.3 Foreign Key Constraints

By default the SQLite ODB runtime enables foreign key constraints
checking (PRAGMA foreign_keys=ON). You can disable foreign
keys by passing false as the foreign_keys
argument to one of the odb::sqlite::database constructors.
Foreign keys will also be disabled if the SQLite library is built without
support for foreign keys (SQLITE_OMIT_FOREIGN_KEY and
SQLITE_OMIT_TRIGGER macros) or if you are using
an SQLite version prior to 3.6.19, which does not support foreign
key constraints checking.

If foreign key constraints checking is disabled or not available,
then inconsistencies in object relationships will not be detected.
Furthermore, using the erase_query() function
(Section 3.11, "Deleting Persistent Objects")
to delete persistent objects that contain containers will not work
correctly. Container data for such objects will not be deleted.

When foreign key constraints checking is enabled, then you may
get the "foreign key constraint failed" error while re-creating the
database schema. This error is due to bugs in the SQLite DDL foreign
keys support. The recommended work-around for this problem is to
temporarily disable foreign key constraints checking while
re-creating the schema. The following code fragment shows how
this can be done:


#include <odb/connection.hxx>
#include <odb/transaction.hxx>
#include <odb/schema-catalog.hxx>

odb::database& db = ...

{
odb::connection_ptr c (db.connection ());

c->execute ("PRAGMA foreign_keys=OFF");

odb::transaction t (c->begin ());
odb::schema_catalog::create_schema (db);
t.commit ();

c->execute ("PRAGMA foreign_keys=ON");
}


Finally, ODB relies on standard SQL behavior which requires
that foreign key constraints checking is deferred until the
transaction is committed. Default SQLite behavior is to check such
constraints immediately. As a result, when used with ODB, a custom
database schema that defines foreign key constraints must declare
such constraints as DEFERRABLE INITIALLY DEFERRED, as
shown in the following example. Schemas generated by the ODB compiler
meet this requirement automatically.


CREATE TABLE Employee (
...
employer INTEGER REFERENCES Employer(id)
DEFERRABLE INITIALLY DEFERRED);



16.5.4 Constraint Violations

Due to the granularity of the SQLite error codes, it is impossible
to distinguish between the duplicate primary key and other constraint
violations. As a result, when making an object persistent, the SQLite
ODB runtime will translate all constraint violation errors to the
object_already_persistent exception (Section
3.14, "ODB Exceptions").

16.5.5 Sharing of Queries

As discussed in Section 4.3, "Executing a Query", a
query instance that does not have any by-reference parameters is
immutable and can be shared between multiple threads without
synchronization. Currently, the SQLite ODB runtime does not support this
functionality. Future versions of the library will remove this
limitation.

16.6 SQLite Index Definitions

When the index pragma (Section 12.6,
"Index Definition Pragmas") is used to define an SQLite index,
the type clause specifies the index type (for example,
UNIQUE) while the method and
options clauses are not used. The column options
can be used to specify collations and the sort order. For example:


#pragma db object
class object
{
...

std::string name_;

#pragma db index member(name_, "COLLATE binary DESC")
};


Index names in SQLite are database-global. To avoid name clashes,
ODB automatically prefixes each index name with the table name on
which it is defined.





17 PostgreSQL Database

To generate support code for the PostgreSQL database you will need
to pass the "--database pgsql"
(or "-d pgsql") option to the ODB compiler.
Your application will also need to link to the PostgreSQL ODB runtime
library (libodb-pgsql). All PostgreSQL-specific ODB
classes are defined in the odb::pgsql namespace.

ODB utilizes prepared statements extensively. Support for prepared
statements was added in PostgreSQL version 7.4 with the introduction
of the messaging protocol version 3.0. For this reason, ODB supports
only PostgreSQL version 7.4 and later.

17.1 PostgreSQL Type Mapping

The following table summarizes the default mapping between basic
C++ value types and PostgreSQL database types. This mapping can be
customized on the per-type and per-member basis using the ODB
Pragma Language (Chapter 12, "ODB Pragma
Language").




C++ Type
PostgreSQL Type
Default NULL Semantics



bool
BOOLEAN
NOT NULL



char
CHAR(1)
NOT NULL



signed char
SMALLINT
NOT NULL



unsigned char
SMALLINT
NOT NULL



short
SMALLINT NULL
NOT NULL



unsigned short
SMALLINT
NOT NULL



int
INTEGER
NOT NULL



unsigned int
INTEGER
NOT NULL



long
BIGINT
NOT NULL



unsigned long
BIGINT
NOT NULL



long long
BIGINT
NOT NULL



unsigned long long
BIGINT
NOT NULL



float
REAL
NOT NULL



double
DOUBLE PRECISION
NOT NULL



std::string
TEXT
NOT NULL



char[N]
VARCHAR(N-1)
NOT NULL



It is possible to map the char C++ type to an integer
database type (for example, SMALLINT) using the
db type pragma (Section 12.4.3,
"type").

Additionally, by default, C++ enumerations are automatically
mapped to INTEGER with the default NULL
semantics being NOT NULL.

Note also that because PostgreSQL does not support unsigned integers,
the unsigned short, unsigned int, and
unsigned long/unsigned long long C++ types
are by default mapped to the SMALLINT, INTEGER,
and BIGINT PostgreSQL types, respectively. The sign bit
of the value stored by the database for these types will contain
the most significant bit of the actual unsigned value being
persisted.

It is also possible to add support for additional PostgreSQL types,
such as NUMERIC, geometry types, XML,
JSON, enumeration types, composite types, arrays,
geospatial types, and the key-value store (HSTORE).
For more information, refer to Section 12.7,
"Database Type Mapping Pragmas".

17.1.1 String Type Mapping

The PostgreSQL ODB runtime library provides support for mapping the
std::string, char[N], and
std::array<char, N> types to the PostgreSQL
CHAR, VARCHAR, and TEXT
types. However, these mappings are not enabled by default (in
particular, by default, std::array will be treated
as a container). To enable the alternative mappings for these
types we need to specify the database type explicitly using the
db type pragma (Section 12.4.3,
"type"), for example:


#pragma db object
class object
{
...

#pragma db type("CHAR(2)")
char state_[2];

#pragma db type("VARCHAR(128)")
std::string name_;
};


Alternatively, this can be done on the per-type basis, for example:


#pragma db value(std::string) type("VARCHAR(128)")

#pragma db object
class object
{
...

std::string name_; // Mapped to VARCHAR(128).
};


The char[N] and std::array<char, N> values
may or may not be zero-terminated. When extracting such values from the
database, ODB will append the zero terminator if there is enough
space.

17.1.2 Binary Type and UUID Mapping

The PostgreSQL ODB runtime library provides support for mapping the
std::vector<char>,
std::vector<unsigned char>,
char[N], unsigned char[N],
std::array<char, N>, and
std::array<unsigned char, N> types to the PostgreSQL
BYTEA type. There is also support for mapping the
char[16] array to the PostgreSQL UUID type.
However, these mappings are not enabled by default (in particular, by
default, std::vector and std::array will be
treated as containers). To enable the alternative mappings for these
types we need to specify the database type explicitly using the
db type pragma (Section 12.4.3,
"type"), for example:


#pragma db object
class object
{
...

#pragma db type("UUID")
char uuid_[16];

#pragma db type("BYTEA")
std::vector<char> buf_;

#pragma db type("BYTEA")
unsigned char data_[256];
};


Alternatively, this can be done on the per-type basis, for example:


typedef std::vector<char> buffer;
#pragma db value(buffer) type("BYTEA")

#pragma db object
class object
{
...

buffer buf_; // Mapped to BYTEA.
};


Note also that in native queries (Chapter 4, "Querying
the Database") char[N] and
std::array<char, N> parameters are by default passed
as a string rather than a binary. To pass such parameters as a binary,
we need to specify the database type explicitly in the
_val()/_ref() calls. Note also that we
don't need to do this for the integrated queries, for example:


char u[16] = {...};

db.query<object> ("uuid = " + query::_val<odb::pgsql::id_uuid> (u));
db.query<object> ("buf = " + query::_val<odb::pgsql::id_bytea> (u));
db.query<object> (query::uuid == query::_ref (u));


17.2 PostgreSQL Database Class

The PostgreSQL database class has the following
interface:


namespace odb
{
namespace pgsql
{
class database: public odb::database
{
public:
database (const std::string& user,
const std::string& password,
const std::string& db,
const std::string& host = "",
unsigned int port = 0,
const std::string& extra_conninfo = "",
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string& password,
const std::string& db,
const std::string& host,
const std::string& socket_ext,
const std::string& extra_conninfo = "",
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& conninfo,
std::[auto|unique]_ptr<connection_factory> = 0);

database (int& argc,
char* argv[],
bool erase = false,
const std::string& extra_conninfo = "",
std::[auto|unique]_ptr<connection_factory> = 0);

static void
print_usage (std::ostream&);

public:
const std::string&
user () const;

const std::string&
password () const;

const std::string&
db () const;

const std::string&
host () const;

unsigned int
port () const;

const std::string&
socket_ext () const;

const std::string&
extra_conninfo () const;

const std::string&
conninfo () const;

public:
connection_ptr
connection ();
};
}
}


You will need to include the <odb/pgsql/database.hxx>
header file to make this class available in your application.

The overloaded database constructors allow us to specify
the PostgreSQL database parameters that should be used when connecting
to the database. The port argument in the first constructor
is an integer value specifying the TCP/IP port number to connect to. A
zero port number indicates that the default port should be used.
The socket_ext argument in the second constructor is a
string value specifying the UNIX-domain socket file name extension.

The third constructor allows us to specify all the database parameters
as a single conninfo string. All other constructors
accept additional database connection parameters as the
extra_conninfo argument. For more information
about the format of the conninfo string, refer to
the PQconnectdb() function description in the PostgreSQL
documentation. In the case of extra_conninfo, all the
database parameters provided in this string will take precedence
over those explicitly specified with other constructor arguments.

The last constructor extracts the database parameters
from the command line. The following options are recognized:


--user <login> | --username <login>
--password <password>
--database <name> | --dbname <name>
--host <host>
--port <integer>
--options-file <file>


The --options-file option allows us to specify some
or all of the database options in a file with each option appearing
on a separate line followed by a space and an option value.

If the erase argument to this constructor is true,
then the above options are removed from the argv
array and the argc count is updated accordingly.
This is primarily useful if your application accepts other
options or arguments and you would like to get the PostgreSQL
options out of the argv array.

This constructor throws the odb::pgsql::cli_exception
exception if the PostgreSQL option values are missing or invalid.
See section Section 17.4, "PostgreSQL Exceptions"
for more information on this exception.

The static print_usage() function prints the list of options
with short descriptions that are recognized by this constructor.

The last argument to all of the constructors is a pointer to the
connection factory. In C++98/03, it is std::auto_ptr while
in C++11 std::unique_ptr is used instead. If we pass a
non-NULL value, the database instance assumes ownership
of the factory instance. The connection factory interface as well as
the available implementations are described in the next section.

The set of accessor functions following the constructors allows us
to query the parameters of the database instance. Note that
the conninfo() accessor returns a complete
conninfo string which includes parameters that were
explicitly specified with the various constructor arguments, as well as
the extra parameters passed in the extra_conninfo argument.
The extra_conninfo() accessor will return the
conninfo string as passed in the extra_conninfo
argument.

The connection() function returns a pointer to the
PostgreSQL database connection encapsulated by the
odb::pgsql::connection class. For more information
on pgsql::connection, refer to Section
17.3, "PostgreSQL Connection and Connection Factory".

17.3 PostgreSQL Connection and Connection Factory

The pgsql::connection class has the following interface:


namespace odb
{
namespace pgsql
{
class connection: public odb::connection
{
public:
connection (database&);
connection (database&, PGconn*);

PGconn*
handle ();
};

typedef details::shared_ptr<connection> connection_ptr;
}
}


For more information on the odb::connection interface,
refer to Section 3.6, "Connections". The first
overloaded pgsql::connection constructor establishes a
new PostgreSQL connection. The second constructor allows us to create
a connection instance by providing an already connected
native PostgreSQL handle. Note that the connection
instance assumes ownership of this handle. The handle()
accessor returns the PostgreSQL handle corresponding to the connection.

The pgsql::connection_factory abstract class has the
following interface:


namespace odb
{
namespace pgsql
{
class connection_factory
{
public:
virtual void
database (database&) = 0;

virtual connection_ptr
connect () = 0;
};
}
}


The database() function is called when a connection
factory is associated with a database instance. This happens in
the odb::pgsql::database class constructors. The
connect() function is called whenever a database
connection is requested.

The two implementations of the connection_factory
interface provided by the PostgreSQL ODB runtime are
new_connection_factory and
connection_pool_factory. You will need to include
the <odb/pgsql/connection-factory.hxx>
header file to make the connection_factory interface
and these implementation classes available in your application.

The new_connection_factory class creates a new
connection whenever one is requested. When a connection is no
longer needed, it is released and closed. The
new_connection_factory class has the following
interface:


namespace odb
{
namespace pgsql
{
class new_connection_factory: public connection_factory
{
public:
new_connection_factory ();
};
};


The connection_pool_factory class implements a
connection pool. It has the following interface:


namespace odb
{
namespace pgsql
{
class connection_pool_factory: public connection_factory
{
public:
connection_pool_factory (std::size_t max_connections = 0,
std::size_t min_connections = 0);

protected:
class pooled_connection: public connection
{
public:
pooled_connection (database_type&);
pooled_connection (database_type&, PGconn*);
};

typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;

virtual pooled_connection_ptr
create ();
};
};


The max_connections argument in the
connection_pool_factory constructor specifies the maximum
number of concurrent connections that this pool factory will
maintain. Similarly, the min_connections argument
specifies the minimum number of available connections that
should be kept open.

Whenever a connection is requested, the pool factory first
checks if there is an unused connection that can be returned.
If there is none, the pool factory checks the
max_connections value to see if a new connection
can be created. If the total number of connections maintained
by the pool is less than this value, then a new connection is
created and returned. Otherwise, the caller is blocked until
a connection becomes available.

When a connection is released, the pool factory first checks
if there are blocked callers waiting for a connection. If so, then
one of them is unblocked and is given the connection. Otherwise,
the pool factory checks whether the total number of connections
maintained by the pool is greater than the min_connections
value. If that's the case, the connection is closed. Otherwise, the
connection is added to the pool of available connections to be
returned on the next request. In other words, if the number of
connections maintained by the pool exceeds min_connections
and there are no callers waiting for a new connection,
the pool will close the excess connections.

If the max_connections value is 0, then the pool will
create a new connection whenever all of the existing connections
are in use. If the min_connections value is 0, then
the pool will never close a connection and instead maintain all
the connections that were ever created.

The create() virtual function is called whenever the
pool needs to create a new connection. By deriving from the
connection_pool_factory class and overriding this
function we can implement custom connection establishment
and configuration.

If you pass NULL as the connection factory to one of the
database constructors, then the
connection_pool_factory instance will be created by default
with the min and max connections values set to 0. The
following code fragment shows how we can pass our own connection factory
instance:


#include <odb/database.hxx>

#include <odb/pgsql/database.hxx>
#include <odb/pgsql/connection-factory.hxx>

int
main (int argc, char* argv[])
{
auto_ptr<odb::pgsql::connection_factory> f (
new odb::pgsql::connection_pool_factory (20));

auto_ptr<odb::database> db (
new pgsql::database (argc, argv, false, "", f));
}


17.4 PostgreSQL Exceptions

The PostgreSQL ODB runtime library defines the following
PostgreSQL-specific exceptions:


namespace odb
{
namespace pgsql
{
class database_exception: odb::database_exception
{
public:
const std::string&
message () const;

const std::string&
sqlstate () const;

virtual const char*
what () const throw ();
};

class cli_exception: odb::exception
{
public:
virtual const char*
what () const throw ();
};
}
}


You will need to include the <odb/pgsql/exceptions.hxx>
header file to make these exceptions available in your application.

The odb::pgsql::database_exception is thrown if
a PostgreSQL database operation fails. The PostgreSQL-specific error
information is accessible via the message() and
sqlstate() functions. All this information is also
combined and returned in a human-readable form by the what()
function.

The odb::pgsql::cli_exception is thrown by the
command line parsing constructor of the odb::pgsql::database
class if the PostgreSQL option values are missing or invalid. The
what() function returns a human-readable description
of an error.

17.5 PostgreSQL Limitations

The following sections describe PostgreSQL-specific limitations imposed
by the current PostgreSQL and ODB runtime versions.

17.5.1 Query Result Caching

The PostgreSQL ODB runtime implementation will always return a
cached query result (Section 4.4, "Query Result")
even when explicitly requested not to. This is a limitation of the
PostgreSQL client library (libpq) which does not
support uncached (streaming) query results.

17.5.2 Foreign Key Constraints

ODB relies on standard SQL behavior which requires that
foreign key constraints checking is deferred until the
transaction is committed. Default PostgreSQL behavior is
to check such constraints immediately. As a result, when
used with ODB, a custom database schema that defines foreign
key constraints must declare such constraints as
INITIALLY DEFERRED, as shown in the following example.
Schemas generated by the ODB compiler meet this requirement
automatically.


CREATE TABLE Employee (
...
employer BIGINT REFERENCES Employer(id) INITIALLY DEFERRED);


17.5.3 Unique Constraint Violations

Due to the granularity of the PostgreSQL error codes, it is impossible
to distinguish between the duplicate primary key and other unique
constraint violations. As a result, when making an object persistent,
the PostgreSQL ODB runtime will translate all unique constraint violation
errors to the object_already_persistent exception
(Section 3.14, "ODB Exceptions").

17.5.4 Date-Time Format

ODB expects the PostgreSQL server to use integers as a binary
format for the date-time types, which is the default for most
PostgreSQL configurations. When creating a connection, ODB
examines the integer_datetimes PostgreSQL server
parameter and if it is false,
odb::pgsql::database_exception is thrown. You may
check the value of this parameter for your server by executing
the following SQL query:


SHOW integer_datetimes


17.5.5 Timezones

ODB does not currently natively support the PostgreSQL date-time types
with timezone information. However, these types can be accessed by
mapping them to one of the natively supported types, as discussed
in Section 12.7, "Database Type Mapping Pragmas".

17.5.6 NUMERIC Type Support

Support for the PostgreSQL NUMERIC type is limited
to providing a binary buffer containing the binary representation
of the value. For more information on the binary format used to
store NUMERIC values refer to the PostgreSQL
documentation. An alternative approach to accessing NUMERIC
values is to map this type to one of the natively supported
ones, as discussed in Section 12.7, "Database
Type Mapping Pragmas".


17.6 PostgreSQL Index Definitions

When the index pragma (Section 12.6,
"Index Definition Pragmas") is used to define a PostgreSQL index,
the type clause specifies the index type (for example,
UNIQUE), the method clause specifies the
index method (for example, BTREE, HASH,
GIN, etc.), and the options clause
specifies additional index options, such as storage parameters,
table spaces, and the WHERE predicate. To support
the definition of concurrent indexes, the type
clause can end with the word CONCURRENTLY (upper and
lower cases are recognized). The column options can be used to
specify collations, operator classes, and the sort order. For example:


#pragma db object
class object
{
...

std::string name_;

#pragma db index \
type("UNIQUE CONCURRENTLY") \
method("HASH") \
member(name_, "DESC") \
options("WITH(FILLFACTOR = 80)")
};


Index names in PostgreSQL are schema-global. To avoid name clashes,
ODB automatically prefixes each index name with the table name on
which it is defined.





18 Oracle Database

To generate support code for the Oracle database you will need
to pass the "--database oracle"
(or "-d oracle") option to the ODB compiler.
Your application will also need to link to the Oracle ODB runtime
library (libodb-oracle). All Oracle-specific ODB
classes are defined in the odb::oracle namespace.

18.1 Oracle Type Mapping

The following table summarizes the default mapping between basic
C++ value types and Oracle database types. This mapping can be
customized on the per-type and per-member basis using the ODB
Pragma Language (Chapter 12, "ODB Pragma
Language").




C++ Type
Oracle Type
Default NULL Semantics



bool
NUMBER(1)
NOT NULL



char
CHAR(1)
NOT NULL



signed char
NUMBER(3)
NOT NULL



unsigned char
NUMBER(3)
NOT NULL



short
NUMBER(5)
NOT NULL



unsigned short
NUMBER(5)
NOT NULL



int
NUMBER(10)
NOT NULL



unsigned int
NUMBER(10)
NOT NULL



long
NUMBER(19)
NOT NULL



unsigned long
NUMBER(20)
NOT NULL



long long
NUMBER(19)
NOT NULL



unsigned long long
NUMBER(20)
NOT NULL



float
BINARY_FLOAT
NOT NULL



double
BINARY_DOUBLE
NOT NULL



std::string
VARCHAR2(512)
NULL



char[N]
VARCHAR2(N-1)
NULL



It is possible to map the char C++ type to an integer
database type (for example, NUMBER(3)) using the
db type pragma (Section 12.4.3,
"type").

In Oracle empty VARCHAR2 and NVARCHAR2
strings are represented as a NULL value. As a result,
columns of the std::string and char[N]
types are by default declared as NULL except for
primary key columns. However, you can override this by explicitly
declaring such columns as NOT NULL with the
db not_null pragma (Section
12.4.6, "null/not_null"). This also means that for
object ids that are mapped to these Oracle types, an empty string is
an invalid value.

Additionally, by default, C++ enumerations are automatically
mapped to NUMBER(10) with the default NULL
semantics being NOT NULL.

It is also possible to add support for additional Oracle types,
such as XML, geospatial types, user-defined types,
and collections (arrays, table types). For more information, refer to
Section 12.7, "Database Type Mapping
Pragmas".

18.1.1 String Type Mapping

The Oracle ODB runtime library provides support for mapping the
std::string, char[N], and
std::array<char, N> types to the Oracle CHAR,
VARCHAR2, CLOB, NCHAR,
NVARCHAR2, and NCLOB types. However,
these mappings are not enabled by default (in particular, by
default, std::array will be treated as a container).
To enable the alternative mappings for these types we need to
specify the database type explicitly using the db type
pragma (Section 12.4.3, "type"),
for example:


#pragma db object
class object
{
...

#pragma db type ("CHAR(2)")
char state_[2];

#pragma db type ("VARCHAR(128)") null
std::string name_;

#pragma db type ("CLOB")
std::string text_;
};


Alternatively, this can be done on the per-type basis, for example:


#pragma db value(std::string) type("VARCHAR(128)") null

#pragma db object
class object
{
...

std::string name_; // Mapped to VARCHAR(128).

#pragma db type ("CLOB")
std::string text_; // Mapped to CLOB.
};


The char[N] and std::array<char, N> values
may or may not be zero-terminated. When extracting such values from the
database, ODB will append the zero terminator if there is enough
space.

18.1.2 Binary Type Mapping

The Oracle ODB runtime library provides support for mapping the
std::vector<char>,
std::vector<unsigned char>,
char[N], unsigned char[N],
std::array<char, N>, and
std::array<unsigned char, N>
types to the Oracle BLOB and RAW types.
However, these mappings are not enabled by default (in particular, by
default, std::vector and std::array will be
treated as containers). To enable the alternative mappings for these
types we need to specify the database type explicitly using the
db type pragma (Section 12.4.3,
"type"), for example:


#pragma db object
class object
{
...

#pragma db type("BLOB")
std::vector<char> buf_;

#pragma db type("RAW(16)")
unsigned char uuid_[16];
};


Alternatively, this can be done on the per-type basis, for example:


typedef std::vector<char> buffer;
#pragma db value(buffer) type("BLOB")

#pragma db object
class object
{
...

buffer buf_; // Mapped to BLOB.
};


Note also that in native queries (Chapter 4, "Querying
the Database") char[N] and
std::array<char, N> parameters are by default passed
as a string rather than a binary. To pass such parameters as a binary,
we need to specify the database type explicitly in the
_val()/_ref() calls. Note also that we
don't need to do this for the integrated queries, for example:


char u[16] = {...};

db.query<object> ("uuid = " + query::_val<odb::oracle::id_raw> (u));
db.query<object> (query::uuid == query::_ref (u));


18.2 Oracle Database Class

The Oracle database class encapsulates the OCI environment
handle as well as the database connection string and user credentials
that are used to establish connections to the database. It has the
following interface:


namespace odb
{
namespace oracle
{
class database: public odb::database
{
public:
database (const std::string& user,
const std::string& password,
const std::string& db,
ub2 charset = 0,
ub2 ncharset = 0,
OCIEnv* environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string& password,
const std::string& service,
const std::string& host,
unsigned int port = 0,
ub2 charset = 0,
ub2 ncharset = 0,
OCIEnv* environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (int& argc,
char* argv[],
bool erase = false,
ub2 charset = 0,
ub2 ncharset = 0,
OCIEnv* environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

static void
print_usage (std::ostream&);

public:
const std::string&
user () const;

const std::string&
password () const;

const std::string&
db () const;

const std::string&
service () const;

const std::string&
host () const;

unsigned int
port () const;

ub2
charset () const;

ub2
ncharset () const;

OCIEnv*
environment ();

public:
connection_ptr
connection ();
};
}
}


You will need to include the <odb/oracle/database.hxx>
header file to make this class available in your application.

The overloaded database constructors allow us to specify the
Oracle database parameters that should be used when connecting to the
database. The db argument in the first constructor is a
connection identifier that specifies the database to connect to. For more
information on the format of the connection identifier, refer to the
Oracle documentation.

The second constructor allows us to specify the individual components
of a connection identifier as the service, host,
and port arguments. If the host argument is
empty, then localhost is used by default. Similarly, if the
port argument is zero, then the default port is used.

The last constructor extracts the database parameters
from the command line. The following options are recognized:


--user <login>
--password <password>
--database <connect-id>
--service <name>
--host <host>
--port <integer>
--options-file <file>


The --options-file option allows us to specify some
or all of the database options in a file with each option appearing
on a separate line followed by a space and an option value. Note that it
is invalid to specify the --database option
together with --service, --host, or
--port options.

If the erase argument to this constructor is true,
then the above options are removed from the argv
array and the argc count is updated accordingly.
This is primarily useful if your application accepts other
options or arguments and you would like to get the Oracle
options out of the argv array.

This constructor throws the odb::oracle::cli_exception
exception if the Oracle option values are missing or invalid. See section
Section 18.4, "Oracle Exceptions" for more
information on this exception.

The static print_usage() function prints the list of options
with short descriptions that are recognized by this constructor.

Additionally, all the constructors have the charset,
ncharset, and environment arguments.
The charset argument specifies the client-side database
character encoding. Character data corresponding to the CHAR,
VARCHAR2, and CLOB types will be delivered
to and received from the application in this encoding. Similarly,
the ncharset argument specifies the client-side national
character encoding. Character data corresponding to the NCHAR,
NVARCHAR2, and NCLOB types will be delivered
to and received from the application in this encoding. For the complete
list of available character encoding values, refer to the Oracle
documentation. Commonly used encoding values are 873
(UTF-8), 31 (ISO-8859-1), and 1000 (UTF-16).
If the database character encoding is not specified, then the
NLS_LANG environment/registry variable is used. Similarly,
if the national character encoding is not specified, then the
NLS_NCHAR environment/registry variable is used. For more
information on character encodings, refer to the
OCIEnvNlsCreate() function in the Oracle Call Interface
(OCI) documentation.

The environment argument allows us to provide a custom
OCI environment handle. If this argument is not NULL,
then the passed handle is used in all the OCI function calls made
by this database class instance. Note also that the
database instance does not assume ownership of the
passed environment handle and this handle should be valid for
the lifetime of the database instance. If a custom
environment handle is used, then the charset and
ncharset arguments have no effect.

The last argument to all of the constructors is a pointer to the
connection factory. In C++98/03, it is std::auto_ptr while
in C++11 std::unique_ptr is used instead. If we pass a
non-NULL value, the database instance assumes ownership
of the factory instance. The connection factory interface as well as
the available implementations are described in the next section.

The set of accessor functions following the constructors allows us
to query the parameters of the database instance.

The connection() function returns a pointer to the
Oracle database connection encapsulated by the
odb::oracle::connection class. For more information
on oracle::connection, refer to Section
18.3, "Oracle Connection and Connection Factory".

18.3 Oracle Connection and Connection Factory

The oracle::connection class has the following interface:


namespace odb
{
namespace oracle
{
class connection: public odb::connection
{
public:
connection (database&);
connection (database&, OCISvcCtx*);

OCISvcCtx*
handle ();

OCIError*
error_handle ();

details::buffer&
lob_buffer ();
};

typedef details::shared_ptr<connection> connection_ptr;
}
}


For more information on the odb::connection interface, refer
to Section 3.6, "Connections". The first overloaded
oracle::connection constructor creates a new OCI service
context. The OCI statement caching is enabled for the underlying session
while the OCI connection pooling and session pooling are not used. The
second constructor allows us to create a connection instance by
providing an already connected Oracle service context. Note that the
connection instance assumes ownership of this handle. The
handle() accessor returns the OCI service context handle
associated with the connection instance.

An OCI error handle is allocated for each connection
instance and is available via the error_handle() accessor
function.

Additionally, each connection instance maintains a large
object (LOB) buffer. This buffer is used by the Oracle ODB runtime
as an intermediate storage for piecewise handling of LOB data.
By default, the LOB buffer has zero initial capacity and is
expanded to 4096 bytes when the first LOB operation is performed.
If your application requires a bigger or smaller LOB buffer, you can
specify a custom capacity using the lob_buffer()
accessor.

The oracle::connection_factory abstract class has the
following interface:


namespace odb
{
namespace oracle
{
class connection_factory
{
public:
virtual void
database (database&) = 0;

virtual connection_ptr
connect () = 0;
};
}
}


The database() function is called when a connection
factory is associated with a database instance. This happens in
the odb::oracle::database class constructors. The
connect() function is called whenever a database
connection is requested.

The two implementations of the connection_factory
interface provided by the Oracle ODB runtime are
new_connection_factory and
connection_pool_factory. You will need to include
the <odb/oracle/connection-factory.hxx>
header file to make the connection_factory interface
and these implementation classes available in your application.

The new_connection_factory class creates a new
connection whenever one is requested. When a connection is no
longer needed, it is released and closed. The
new_connection_factory class has the following
interface:


namespace odb
{
namespace oracle
{
class new_connection_factory: public connection_factory
{
public:
new_connection_factory ();
};
};


The connection_pool_factory class implements a
connection pool. It has the following interface:


namespace odb
{
namespace oracle
{
class connection_pool_factory: public connection_factory
{
public:
connection_pool_factory (std::size_t max_connections = 0,
std::size_t min_connections = 0);

protected:
class pooled_connection: public connection
{
public:
pooled_connection (database_type&);
pooled_connection (database_type&, OCISvcCtx*);
};

typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;

virtual pooled_connection_ptr
create ();
};
};


The max_connections argument in the
connection_pool_factory constructor specifies the maximum
number of concurrent connections that this pool factory will
maintain. Similarly, the min_connections argument
specifies the minimum number of available connections that
should be kept open.

Whenever a connection is requested, the pool factory first
checks if there is an unused connection that can be returned.
If there is none, the pool factory checks the
max_connections value to see if a new connection
can be created. If the total number of connections maintained
by the pool is less than this value, then a new connection is
created and returned. Otherwise, the caller is blocked until
a connection becomes available.

When a connection is released, the pool factory first checks
if there are blocked callers waiting for a connection. If so, then
one of them is unblocked and is given the connection. Otherwise,
the pool factory checks whether the total number of connections
maintained by the pool is greater than the min_connections
value. If that's the case, the connection is closed. Otherwise, the
connection is added to the pool of available connections to be
returned on the next request. In other words, if the number of
connections maintained by the pool exceeds min_connections
and there are no callers waiting for a new connection,
the pool will close the excess connections.

If the max_connections value is 0, then the pool will
create a new connection whenever all of the existing connections
are in use. If the min_connections value is 0, then
the pool will never close a connection and instead maintain all
the connections that were ever created.

The create() virtual function is called whenever the
pool needs to create a new connection. By deriving from the
connection_pool_factory class and overriding this
function we can implement custom connection establishment
and configuration.

If you pass NULL as the connection factory to one of the
database constructors, then the
connection_pool_factory instance will be created by default
with the min and max connections values set to 0. The
following code fragment shows how we can pass our own connection factory
instance:


#include <odb/database.hxx>

#include <odb/oracle/database.hxx>
#include <odb/oracle/connection-factory.hxx>

int
main (int argc, char* argv[])
{
auto_ptr<odb::oracle::connection_factory> f (
new odb::oracle::connection_pool_factory (20));

auto_ptr<odb::database> db (
new oracle::database (argc, argv, false, 0, 0, 0, f));
}


18.4 Oracle Exceptions

The Oracle ODB runtime library defines the following
Oracle-specific exceptions:


namespace odb
{
namespace oracle
{
class database_exception: odb::database_exception
{
public:
class record
{
public:
sb4
error () const;

const std::string&
message () const;
};

typedef std::vector<record> records;

typedef records::size_type size_type;
typedef records::const_iterator iterator;

iterator
begin () const;

iterator
end () const;

size_type
size () const;

virtual const char*
what () const throw ();
};

class cli_exception: odb::exception
{
public:
virtual const char*
what () const throw ();
};

class invalid_oci_handle: odb::exception
{
public:
virtual const char*
what () const throw ();
};
}
}


You will need to include the <odb/oracle/exceptions.hxx>
header file to make these exceptions available in your application.

The odb::oracle::database_exception is thrown if
an Oracle database operation fails. The Oracle-specific error
information is stored as a series of records, each containing
the error code as a signed 4-byte integer and the message string.
All this information is also combined and returned in a
human-readable form by the what() function.

The odb::oracle::cli_exception is thrown by the
command line parsing constructor of the odb::oracle::database
class if the Oracle option values are missing or invalid. The
what() function returns a human-readable description
of an error.

The odb::oracle::invalid_oci_handle is thrown if an
invalid handle is passed to an OCI function or if an OCI function
was unable to allocate a handle. The former normally indicates
a programming error while the latter indicates an out of memory
condition. The what() function returns a human-readable
description of an error.

18.5 Oracle Limitations

The following sections describe Oracle-specific limitations imposed
by the current Oracle and ODB runtime versions.

18.5.1 Identifier Truncation

Oracle limits the length of database identifiers (table, column, etc.,
names) to 30 characters. The ODB compiler automatically truncates
any identifier that is longer than 30 characters. This, however,
can lead to duplicate names. A common symptom of this problem
are errors during the database schema creation indicating
that a database object with the same name already exists. To
resolve this problem we can assign custom, shorter identifiers
using the db table and db column
pragmas (Chapter 12, "ODB Pragma Language"). For
example:


#pragma db object
class long_class_name
{
...

std::vector<int> long_container_x_;
std::vector<int> long_container_y_;
};


In the above example, the names of the two container tables will be
long_class_name_long_container_x_ and
long_class_name_long_container_y_. However, when
truncated to 30 characters, they both become
long_class_name_long_container. To resolve this
collision we can assign a custom table name for each container:


#pragma db object
class long_class_name
{
...

#pragma db table("long_class_name_cont_x")
std::vector<int> long_container_x_;

#pragma db table("long_class_name_cont_y")
std::vector<int> long_container_y_;
};


18.5.2 Query Result Caching

Oracle ODB runtime implementation does not perform query result caching
(Section 4.4, "Query Result") even when explicitly
requested. The OCI API supports interleaving execution of multiple
prepared statements on a single connection. As a result, with OCI,
it is possible to have multiple uncached results and calls to other
database functions do not invalidate them. The only limitation of
the uncached Oracle results is the unavailability of the
result::size() function. If you call this function on
an Oracle query result, then the odb::result_not_cached
exception (Section 3.14, "ODB Exceptions") is
always thrown. Future versions of the Oracle ODB runtime library
may add support for result caching.

18.5.3 Foreign Key Constraints

ODB relies on standard SQL behavior which requires that
foreign key constraints checking is deferred until the
transaction is committed. Default Oracle behavior is
to check such constraints immediately. As a result, when
used with ODB, a custom database schema that defines foreign
key constraints must declare such constraints as
INITIALLY DEFERRED, as shown in the following example.
Schemas generated by the ODB compiler meet this requirement
automatically.


CREATE TABLE Employee (
...
employer NUMBER(20) REFERENCES Employer(id)
DEFERRABLE INITIALLY DEFERRED);


18.5.4 Unique Constraint Violations

Due to the granularity of the Oracle error codes, it is impossible
to distinguish between the duplicate primary key and other unique
constraint violations. As a result, when making an object persistent,
the Oracle ODB runtime will translate all unique constraint violation
errors to the object_already_persistent exception
(Section 3.14, "ODB Exceptions").

18.5.5 Large FLOAT and
NUMBER Types

The Oracle FLOAT type with a binary precision greater
than 53 and fixed-point NUMBER type with a decimal
precision greater than 15 cannot be automatically extracted
into the C++ float and double types.
Instead, the Oracle ODB runtime uses a 21-byte buffer containing
the binary representation of a value as an image type for such
FLOAT and NUMBER types. In order to
convert them into an application-specific large number representation,
you will need to provide a suitable value_traits
template specialization. For more information on the binary format
used to store the FLOAT and NUMBER values,
refer to the Oracle Call Interface (OCI) documentation.

An alternative approach to accessing large FLOAT and
NUMBER values is to map these type to one of the
natively supported ones, as discussed in Section
12.7, "Database Type Mapping Pragmas".

Note that a NUMBER type that is used to represent a
floating point number (declared by specifying NUMBER
without any range and scale) can be extracted into the C++
float and double types.

18.5.6 Timezones

ODB does not currently support the Oracle date-time types with timezone
information. However, these types can be accessed by mapping them to
one of the natively supported types, as discussed in
Section 12.7, "Database Type Mapping Pragmas".

18.5.7 LONG Types

ODB does not support the deprecated Oracle LONG and
LONG RAW data types. However, these types can be accessed
by mapping them to one of the natively supported types, as discussed
in Section 12.7, "Database Type Mapping Pragmas".

18.5.8 LOB Types and By-Value Accessors/Modifiers

As discussed in Section 12.4.5,
"get/set/access", by-value
accessor and modifier expressions cannot be used with data members
of Oracle large object (LOB) data types: BLOB,
CLOB, and NCLOB. The Oracle ODB runtime
uses streaming for reading/writing LOB data directly from/to
data members. As a result, by-reference accessors and modifiers
should be used for these data types.

18.6 Oracle Index Definitions

When the index pragma (Section 12.6,
"Index Definition Pragmas") is used to define an Oracle index,
the type clause specifies the index type (for example,
UNIQUE, BITMAP), the method
clause is not used, and the options clause specifies
additional index properties, such as partitioning, table spaces, etc.
The column options can be used to specify the sort order. For example:


#pragma db object
class object
{
...

std::string name_;

#pragma db index \
type("BITMAP") \
member(name_, "DESC") \
options("TABLESPACE TBS1")
};


Index names in Oracle are schema-global. To avoid name clashes,
ODB automatically prefixes each index name with the table name on
which it is defined.






19 Microsoft SQL Server Database

To generate support code for the SQL Server database you will need
to pass the "--database mssql"
(or "-d mssql") option to the ODB compiler.
Your application will also need to link to the SQL Server ODB runtime
library (libodb-mssql). All SQL Server-specific ODB
classes are defined in the odb::mssql namespace.

19.1 SQL Server Type Mapping

The following table summarizes the default mapping between basic
C++ value types and SQL Server database types. This mapping can be
customized on the per-type and per-member basis using the ODB
Pragma Language (Chapter 12, "ODB Pragma Language").




C++ Type
SQL Server Type
Default NULL Semantics



bool
BIT
NOT NULL



char
CHAR(1)
NOT NULL



signed char
TINYINT
NOT NULL



unsigned char
TINYINT
NOT NULL



short
SMALLINT
NOT NULL



unsigned short
SMALLINT
NOT NULL



int
INT
NOT NULL



unsigned int
INT
NOT NULL



long
BIGINT
NOT NULL



unsigned long
BIGINT
NOT NULL



long long
BIGINT
NOT NULL



unsigned long long
BIGINT
NOT NULL



float
REAL
NOT NULL



double
FLOAT
NOT NULL



std::string
VARCHAR(512)/VARCHAR(256)
NOT NULL



char[N]
VARCHAR(N-1)
NOT NULL



std::wstring
NVARCHAR(512)/NVARCHAR(256)
NOT NULL



wchar_t[N]
NVARCHAR(N-1)
NOT NULL



GUID
UNIQUEIDENTIFIER
NOT NULL




It is possible to map the char C++ type to an integer
database type (for example, TINYINT) using the
db type pragma (Section 12.4.3,
"type").

Note that the std::string and std::wstring
types are mapped differently depending on whether a member of one of
these types is an object id or not. If the member is an object id,
then for this member std::string is mapped
to VARCHAR(256) and std::wstring —
to NVARCHAR(256). Otherwise, std::string
is mapped to VARCHAR(512) and std::wstring
— to NVARCHAR(512). Note also that you can
always change this mapping using the db type pragma
(Section 12.4.3, "type").

Additionally, by default, C++ enumerations are automatically
mapped to INT with the default NULL
semantics being NOT NULL.

Note also that because SQL Server does not support unsigned integers,
the unsigned short, unsigned int, and
unsigned long/unsigned long long C++ types
are by default mapped to the SMALLINT, INT,
and BIGINT SQL Server types, respectively. The sign bit
of the value stored by the database for these types will contain
the most significant bit of the actual unsigned value being
persisted. Similarly, because there is no signed version of the
TINYINT SQL Server type, by default, the
signed char C++ type is mapped to TINYINT.
As a result, the most significant bit of the value stored by the
database for this type will contain the sign bit of the actual
signed value being persisted.

It is also possible to add support for additional SQL Server types,
such as geospatial types, XML, and user-defined types.
For more information, refer to Section 12.7, "Database
Type Mapping Pragmas".

19.1.1 String Type Mapping

The SQL Server ODB runtime library provides support for mapping the
std::string, char[N], and
std::array<char, N> types to the SQL Server
CHAR, VARCHAR, and TEXT
types as well as the std::wstring, wchar_t[N],
and std::array<wchar_t, N> types to NCHAR,
NVARCHAR, and NTEXT. However, these mappings
are not enabled by default (in particular, by default,
std::array will be treated as a container). To enable the
alternative mappings for these types we need to specify the database
type explicitly using the db type pragma
(Section 12.4.3, "type"), for
example:


#pragma db object
class object
{
...

#pragma db type ("CHAR(2)")
char state_[2];

#pragma db type ("NVARCHAR(max)")
std::wstring text_;
};


Alternatively, this can be done on the per-type basis, for example:


#pragma db value(std::wstring) type("NVARCHAR(max)")

#pragma db object
class object
{
...

std::wstring text_; // Mapped to NVARCHAR(max).
};


The char[N], std::array<char, N>,
wchar_t[N], and std::array<wchar_t, N>
values may or may not be zero-terminated. When extracting such values
from the database, ODB will append the zero terminator if there is
enough space.

See also Section 19.1.4, "Long String and Binary
Types" for certain limitations of long string types.

19.1.2 Binary Type and UNIQUEIDENTIFIER Mapping

The SQL Server ODB runtime library also provides support for mapping the
std::vector<char>,
std::vector<unsigned char>,
char[N], unsigned char[N],
std::array<char, N>, and std::array<unsigned char, N>
types to the SQL Server BINARY, VARBINARY, and
IMAGE types. There is also support for mapping the
char[16] array to the SQL Server UNIQUEIDENTIFIER
type. However, these mappings are not enabled by default (in particular,
by default, std::vector and std::array will
be treated as containers). To enable the alternative mappings for these
types we need to specify the database type explicitly using the
db type pragma (Section 12.4.3,
"type"), for example:


#pragma db object
class object
{
...

#pragma db type("UNIQUEIDENTIFIER")
char uuid_[16];

#pragma db type("VARBINARY(max)")
std::vector<char> buf_;

#pragma db type("BINARY(256)")
unsigned char data_[256];
};


Alternatively, this can be done on the per-type basis, for example:


typedef std::vector<char> buffer;
#pragma db value(buffer) type("VARBINARY(max)")

#pragma db object
class object
{
...

buffer buf_; // Mapped to VARBINARY(max).
};


Note also that in native queries (Chapter 4, "Querying
the Database") char[N] and
std::array<char, N> parameters are by default passed
as a string rather than a binary. To pass such parameters as a binary,
we need to specify the database type explicitly in the
_val()/_ref() calls. Note also that we
don't need to do this for the integrated queries, for example:


char u[16] = {...};

db.query<object> ("uuid = " + query::_val<odb::mssql::id_binary> (u));
db.query<object> (
"uuid = " + query::_val<odb::mssql::id_uniqueidentifier> (u));
db.query<object> (query::uuid == query::_ref (u));


See also Section 19.1.4, "Long String and Binary
Types" for certain limitations of long binary types.

19.1.3 ROWVERSION Mapping

ROWVERSION is a special SQL Server data type that is
automatically incremented by the database server whenever a row
is inserted or updated. As such, it is normally used to implement
optimistic concurrency and ODB provides support for using
ROWVERSION instead of the more portable approach
for optimistic concurrency (Chapter 11, "Optimistic
Concurrency").

ROWVERSION is a 64-bit value which is mapped by ODB
to unsigned long long. As a result, to use
ROWVERSION for optimistic concurrency we need to
make sure that the version column is of the unsigned long
long type. We also need to explicitly specify that it
should be mapped to the ROWVERSION data type. For
example:


#pragma db object optimistic
class person
{
...

#pragma db version type("ROWVERSION")
unsigned long long version_;
};


19.1.4 Long String and Binary Types

For SQL Server, ODB handles character, national character, and
binary data in two different ways depending on its maximum length.
If the maximum length (in bytes) is less than or equal to the limit
specified with the --mssql-short-limit ODB compiler
option (1024 by default), then it is treated as short data,
otherwise — long data. For short data ODB pre-allocates
an intermediate buffer of the maximum size and binds it directly
to a parameter or result column. This way the underlying database
API (ODBC) can read/write directly from/to this buffer. In the case
of long data, the data is read/written in chunks using the
SQLGetData()/SQLPutData() ODBC functions.
While the long data approach reduces the amount of memory used by
the application, it may require greater CPU resources.

Long data has a number of limitations. In particular, when setting
a custom short data limit, make sure that it is sufficiently large
so that no object id in the application is treated as long data.
It is also impossible to load an object or view with long data more
than once as part of a query result iteration (Section
4.4, "Query Result"). Any such attempt will result in the
odb::mssql::long_data_reload exception
(Section 19.4, "SQL Server Exceptions"). For
example:


#pragma db object
class object
{
...

int num_;

#pragma db type("VARCHAR(max)") // Long data.
std::string str_;
};

typedef odb::query<object> query;
typedef odb::result<object> result;

transaction t (db.begin ());

result r (db.query<object> (query::num < 100));

for (result::iterator i (r.begin ()); i != r.end (); ++i)
{
if (!i->str_.empty ()) // First load.
{
object o;
i.load (o); // Error: second load, long_data_reload is thrown.
}
}

t.commit ();


Finally, if a native view (Section 9.5, "Native
Views") contains one or more long data members, then such
members should come last both in the select-list of the native
SQL query and the list of data members in the C++ class.

19.2 SQL Server Database Class

The SQL Server database class encapsulates the ODBC
environment handle as well as the server instance address and
user credentials that are used to establish connections to the
database. It has the following interface:


namespace odb
{
namespace mssql
{
enum protocol
{
protocol_auto,
protocol_tcp, // TCP/IP.
protocol_lpc, // Shared memory (local procedure call).
protocol_np // Named pipes.
};

enum transaction_isolation
{
isolation_read_uncommitted,
isolation_read_committed, // SQL Server default.
isolation_repeatable_read,
isolation_snapshot,
isolation_serializable
};

class database: public odb::database
{
public:
typedef protocol protocol_type;
typedef transaction_isolation transaction_isolation_type;

database (const std::string& user,
const std::string& password,
const std::string& db,
const std::string& server,
const std::string& driver = "",
const std::string& extra_connect_string = "",
transaction_isolation_type = isolation_read_committed,
SQLHENV environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string& password,
const std::string& db,
protocol_type protocol = protocol_auto,
const std::string& host = "",
const std::string& instance = "",
const std::string& driver = "",
const std::string& extra_connect_string = "",
transaction_isolation_type = isolation_read_committed,
SQLHENV environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& user,
const std::string& password,
const std::string& db,
const std::string& host,
unsigned int port,
const std::string& driver = "",
const std::string& extra_connect_string = "",
transaction_isolation_type = isolation_read_committed,
SQLHENV environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (const std::string& connect_string,
transaction_isolation_type = isolation_read_committed,
SQLHENV environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

database (int& argc,
char* argv[],
bool erase = false,
const std::string& extra_connect_string = "",
transaction_isolation_type = isolation_read_committed,
SQLHENV environment = 0,
std::[auto|unique]_ptr<connection_factory> = 0);

static void
print_usage (std::ostream&);

public:
const std::string&
user () const;

const std::string&
password () const;

const std::string&
db () const;

protocol_type
protocol () const;

const std::string&
host () const;

const std::string&
instance () const;

unsigned int
port () const;

const std::string&
server () const;

const std::string&
driver () const;

const std::string&
extra_connect_string () const;

transaction_isolation_type
transaction_isolation () const;

const std::string&
connect_string () const;

SQLHENV
environment ();

public:
connection_ptr
connection ();
};
}
}


You will need to include the <odb/mssql/database.hxx>
header file to make this class available in your application.

The overloaded database constructors allow us to specify the
SQL Server database parameters that should be used when connecting to the
database. The user and password arguments
specify the login name and password. If user is empty,
then Windows authentication is used and the password
argument is ignored. The db argument specifies the
database name to open. If it is empty, then the default database for
the user is used.

The server argument in the first constructor specifies
the SQL Server instance address in the standard SQL Server address
format:


[protocol:]host[\instance][,port]


Where protocol can be tcp
(TCP/IP), lpc (shared memory), or
np (named pipe). If protocol is not specified, then a
suitable protocol is automatically selected based on the SQL Server
Native Client configuration. The host component
can be a host name or an IP address. If instance
is not specified, then the default SQL Server instance is assumed.
If port is not specified, then the default SQL Server port is
used (1433). Note that you would normally specify either the
instance name or the port, but not both. If both are specified,
then the instance name is ignored by the SQL Server Native Client
ODBC driver. For more information on the format of the SQL
Server address, refer to the SQL Server Native Client ODBC
driver documentation.

The second and third constructors allow us to specify all these address
components (protocol, host, instance, and port) as separate
arguments. The third constructor always connects using TCP/IP
to the specified host and port.

The driver argument specifies the SQL Server Native
Client ODBC driver that should be used to connect to the database.
If not specified, then the latest available version is used. The
following examples show common ways of connecting to the database
using the first three constructors:


// Connect to the default SQL Server instance on the local machine
// using the default protocol. Login as 'test' with password 'secret'
// and open the 'example_db' database.
//
odb::mssql::database db1 ("test",
"secret",
"example_db");

// As above except use Windows authentication and open the default
// database for this user.
//
odb::mssql::database db2 ("",
"",
"");

// Connect to the default SQL Server instance on 'onega' using the
// default protocol. Login as 'test' with password 'secret' and open
// the 'example_db' database.
//
odb::mssql::database db3 ("test",
"secret",
"example_db"
"onega");

// As above but connect to the 'production' SQL Server instance.
//
odb::mssql::database db4 ("test",
"secret",
"example_db"
"onega\\production");

// Same as above but specify protocol, host, and instance as separate
// arguments.
//
odb::mssql::database db5 ("test",
"secret",
"example_db",
odb::mssql::protocol_auto,
"onega",
"production");

// As above, but use TCP/IP as the protocol.
//
odb::mssql::database db6 ("test",
"secret",
"example_db"
"tcp:onega\\production");

// Same as above but using separate arguments.
//
odb::mssql::database db7 ("test",
"secret",
"example_db",
odb::mssql::protocol_tcp,
"onega",
"production");

// As above, but use TCP/IP port instead of the instance name.
//
odb::mssql::database db8 ("test",
"secret",
"example_db"
"tcp:onega,1435");

// Same as above but using separate arguments. Note that here we
// don't need to specify protocol explicitly since it can only
// be TCP/IP.
//
odb::mssql::database db9 ("test",
"secret",
"example_db",
"onega",
1435);

// As above but use the specific SQL Server Native Client ODBC
// driver version.
//
odb::mssql::database dbA ("test",
"secret",
"example_db"
"tcp:onega,1435",
"SQL Server Native Client 10.0");



The fourth constructor allows us to pass a custom ODBC connection
string that provides all the information necessary to connect to
the database. Note also that all the other constructors have the
extra_connect_string argument which can be used to
specify additional ODBC connection attributes. For more information
on the format of the ODBC connection string, refer to the SQL
Server Native Client ODBC driver documentation.

The last constructor extracts the database parameters
from the command line. The following options are recognized:


--user | -U <login>
--password | -P <password>
--database | -d <name>
--server | -S <address>
--driver <name>
--options-file <file>


The --options-file option allows us to specify some
or all of the database options in a file with each option appearing
on a separate line followed by a space and an option value.

If the erase argument to this constructor is true,
then the above options are removed from the argv
array and the argc count is updated accordingly.
This is primarily useful if your application accepts other
options or arguments and you would like to get the SQL Server
options out of the argv array.

This constructor throws the odb::mssql::cli_exception
exception if the SQL Server option values are missing or invalid. See
section Section 19.4, "SQL Server Exceptions" for
more information on this exception.

The static print_usage() function prints the list of options
with short descriptions that are recognized by this constructor.

Additionally, all the constructors have the transaction_isolation
and environment arguments. The transaction_isolation
argument allows us to specify an alternative transaction isolation level
that should be used by all the connections created by this database instance.
The environment argument allows us to provide a custom ODBC
environment handle. If this argument is not NULL, then the
passed handle is used in all the ODBC function calls made by this
database instance. Note also that the database
instance does not assume ownership of the passed environment handle and
this handle should be valid for the lifetime of the database
instance.

The last argument to all of the constructors is a pointer to the
connection factory. In C++98/03, it is std::auto_ptr while
in C++11 std::unique_ptr is used instead. If we pass a
non-NULL value, the database instance assumes ownership
of the factory instance. The connection factory interface as well as
the available implementations are described in the next section.

The set of accessor functions following the constructors allows us
to query the parameters of the database instance.

The connection() function returns a pointer to the
SQL Server database connection encapsulated by the
odb::mssql::connection class. For more information
on mssql::connection, refer to Section
19.3, "SQL Server Connection and Connection Factory".

19.3 SQL Server Connection and Connection Factory

The mssql::connection class has the following interface:


namespace odb
{
namespace mssql
{
class connection: public odb::connection
{
public:
connection (database&);
connection (database&, SQLHDBC handle);

SQLHDBC
handle ();

details::buffer&
long_data_buffer ();
};

typedef details::shared_ptr<connection> connection_ptr;
}
}


For more information on the odb::connection interface, refer
to Section 3.6, "Connections". The first overloaded
mssql::connection constructor creates a new ODBC connection.
The created connection is configured to use the manual commit mode with
multiple active result sets (MARS) enabled. The second constructor allows
us to create a connection instance by providing an already
established ODBC connection. Note that the connection
instance assumes ownership of this handle. The handle()
accessor returns the underlying ODBC connection handle associated with
the connection instance.

Additionally, each connection instance maintains a long
data buffer. This buffer is used by the SQL Server ODB runtime
as an intermediate storage for piecewise handling of long data.
By default, the long data buffer has zero initial capacity and is
expanded to 4096 bytes when the first long data operation is performed.
If your application requires a bigger or smaller long data buffer,
you can specify a custom capacity using the long_data_buffer()
accessor.

The mssql::connection_factory abstract class has the
following interface:


namespace odb
{
namespace mssql
{
class connection_factory
{
public:
virtual void
database (database&) = 0;

virtual connection_ptr
connect () = 0;
};
}
}


The database() function is called when a connection
factory is associated with a database instance. This happens in
the odb::mssql::database class constructors. The
connect() function is called whenever a database
connection is requested.

The two implementations of the connection_factory
interface provided by the SQL Server ODB runtime are
new_connection_factory and
connection_pool_factory. You will need to include
the <odb/mssql/connection-factory.hxx>
header file to make the connection_factory interface
and these implementation classes available in your application.

The new_connection_factory class creates a new
connection whenever one is requested. When a connection is no
longer needed, it is released and closed. The
new_connection_factory class has the following
interface:


namespace odb
{
namespace mssql
{
class new_connection_factory: public connection_factory
{
public:
new_connection_factory ();
};
};


The connection_pool_factory class implements a
connection pool. It has the following interface:


namespace odb
{
namespace mssql
{
class connection_pool_factory: public connection_factory
{
public:
connection_pool_factory (std::size_t max_connections = 0,
std::size_t min_connections = 0);

protected:
class pooled_connection: public connection
{
public:
pooled_connection (database_type&);
pooled_connection (database_type&, SQLHDBC handle);
};

typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;

virtual pooled_connection_ptr
create ();
};
};


The max_connections argument in the
connection_pool_factory constructor specifies the maximum
number of concurrent connections that this pool factory will
maintain. Similarly, the min_connections argument
specifies the minimum number of available connections that
should be kept open.

Whenever a connection is requested, the pool factory first
checks if there is an unused connection that can be returned.
If there is none, the pool factory checks the
max_connections value to see if a new connection
can be created. If the total number of connections maintained
by the pool is less than this value, then a new connection is
created and returned. Otherwise, the caller is blocked until
a connection becomes available.

When a connection is released, the pool factory first checks
if there are blocked callers waiting for a connection. If so, then
one of them is unblocked and is given the connection. Otherwise,
the pool factory checks whether the total number of connections
maintained by the pool is greater than the min_connections
value. If that's the case, the connection is closed. Otherwise, the
connection is added to the pool of available connections to be
returned on the next request. In other words, if the number of
connections maintained by the pool exceeds min_connections
and there are no callers waiting for a new connection,
the pool will close the excess connections.

If the max_connections value is 0, then the pool will
create a new connection whenever all of the existing connections
are in use. If the min_connections value is 0, then
the pool will never close a connection and instead maintain all
the connections that were ever created.

The create() virtual function is called whenever the
pool needs to create a new connection. By deriving from the
connection_pool_factory class and overriding this
function we can implement custom connection establishment
and configuration.

If you pass NULL as the connection factory to one of the
database constructors, then the
connection_pool_factory instance will be created by default
with the min and max connections values set to 0. The
following code fragment shows how we can pass our own connection factory
instance:


#include <odb/database.hxx>

#include <odb/mssql/database.hxx>
#include <odb/mssql/connection-factory.hxx>

int
main (int argc, char* argv[])
{
auto_ptr<odb::mssql::connection_factory> f (
new odb::mssql::connection_pool_factory (20));

auto_ptr<odb::database> db (
new mssql::database (argc, argv, false, "", 0, f));
}


19.4 SQL Server Exceptions

The SQL Server ODB runtime library defines the following
SQL Server-specific exceptions:


namespace odb
{
namespace mssql
{
class database_exception: odb::database_exception
{
public:
class record
{
public:
SQLINTEGER
error () const;

const std::string&
sqlstate () const;

const std::string&
message () const;
};

typedef std::vector<record> records;

typedef records::size_type size_type;
typedef records::const_iterator iterator;

iterator
begin () const;

iterator
end () const;

size_type
size () const;

virtual const char*
what () const throw ();
};

class cli_exception: odb::exception
{
public:
virtual const char*
what () const throw ();
};

class long_data_reload: odb::exception
{
public:
virtual const char*
what () const throw ();
};
}
}


You will need to include the <odb/mssql/exceptions.hxx>
header file to make these exceptions available in your application.

The odb::mssql::database_exception is thrown if
an SQL Server database operation fails. The SQL Server-specific error
information is stored as a series of records, each containing
the error code as a signed 4-byte integer, the SQLSTATE code,
and the message string. All this information is also combined
and returned in a human-readable form by the what()
function.

The odb::mssql::cli_exception is thrown by the
command line parsing constructor of the odb::mssql::database
class if the SQL Server option values are missing or invalid. The
what() function returns a human-readable description
of an error.

The odb::mssql::long_data_reload is thrown if an
attempt is made to re-load an object or view with long data as
part of a query result iteration. For more information, refer
to Section 19.1, "SQL Server Type Mapping".

19.5 SQL Server Limitations

The following sections describe SQL Server-specific limitations imposed
by the current SQL Server and ODB runtime versions.

19.5.1 Query Result Caching

SQL Server ODB runtime implementation does not perform query result
caching (Section 4.4, "Query Result") even when
explicitly requested. The ODBC API and the SQL Server Native Client ODBC
driver support interleaving execution of multiple prepared statements
on a single connection. As a result, it is possible to have multiple
uncached results and calls to other database functions do not invalidate
them. The only limitation of the uncached SQL Server results is the
unavailability of the result::size() function. If you
call this function on an SQL Server query result, then the
odb::result_not_cached exception (Section
3.14, "ODB Exceptions") is always thrown. Future versions of the
SQL Server ODB runtime library may add support for result caching.

19.5.2 Foreign Key Constraints

ODB relies on standard SQL behavior which requires that foreign
key constraints checking is deferred until the transaction is
committed. The only behavior supported by SQL Server is to check
such constraints immediately. As a result, schemas generated by
the ODB compiler for SQL Server have foreign key definitions
commented out. They are retained only for documentation.

19.5.3 Unique Constraint Violations

Due to the granularity of the ODBC error codes, it is impossible
to distinguish between the duplicate primary key and other unique
constraint violations. As a result, when making an object persistent,
the SQL Server ODB runtime will translate all unique constraint violation
errors to the object_already_persistent exception
(Section 3.14, "ODB Exceptions").

19.5.4 Multi-threaded Windows Applications

Multi-threaded Windows applications must use the
_beginthread()/_beginthreadex() and
_endthread()/_endthreadex() CRT functions
instead of the CreateThread() and EndThread()
Win32 functions to start and terminate threads. This is a limitation of
the ODBC implementation on Windows.

19.5.5 Affected Row Count and DDL Statements

SQL Server always returns zero as the number of affected rows
for DDL statements. In particular, this means that the
database::execute() (Section 3.12,
"Executing Native SQL Statements") function will always
return zero for such statements.

19.5.6 Long Data and Auto Object Ids, ROWVERSION

SQL Server 2005 has a bug that causes it to fail on an INSERT
or UPDATE statement with the OUTPUT clause
(used to return automatically assigned object ids as well as
ROWVERSION values) if one of the inserted columns
is long data. The symptom of this bug in ODB is an exception thrown
by the database::persist() or database::update()
function when used on an object that contains long data and has an
automatically assigned object id or uses ROWVERSION-based
optimistic concurrency (Section 19.1.1,
"ROWVERSION Support"). The error message reads "This
operation conflicts with another pending operation on this transaction.
The operation failed."

For automatically assigned object ids ODB includes a workaround for
this bug which uses a less efficient method to obtain id values for
objects that contain long data. To enable this workaround you need
to specify that the generated code will be used with SQL Server 2005
or later by passing the --mssql-server-version 9.0
ODB compiler option.

For ROWVERSION-based optimistic concurrency no workaround
is currently provided. The ODB compiler will issue an error for
objects that use ROWVERSION for optimistic concurrency
and containing long data.

19.5.7 Long Data and By-Value Accessors/Modifiers

As discussed in Section 12.4.5,
"get/set/access", by-value
accessor and modifier expressions cannot be used with data members
of long data types. The SQL Server ODB runtime uses streaming for
reading/writing long data directly from/to data members. As a result,
by-reference accessors and modifiers should be used for these data
types.

19.6 SQL Server Index Definitions

When the index pragma (Section 12.6,
"Index Definition Pragmas") is used to define an SQL Server index,
the type clause specifies the index type (for example,
UNIQUE, CLUSTERED), the method
clause is not used, and the options clause specifies
additional index properties. The column options can be used to specify
the sort order. For example:


#pragma db object
class object
{
...

std::string name_;

#pragma db index \
type("UNIQUE CLUSTERED") \
member(name_, "DESC") \
options("WITH(FILLFACTOR = 80)")
};







PART III
PROFILES

Part III covers the integration of ODB with popular C++ frameworks
and libraries. It consists of the following chapters.


20Profiles Introduction
21Boost Profile
22Qt Profile







20 Profiles Introduction

ODB profiles are a generic mechanism for integrating ODB with
widely-used C++ frameworks and libraries. A profile provides glue
code which allows you to seamlessly persist various components, such
as smart pointers, containers, and value types found in these
frameworks or libraries. The code necessary to implement a profile
is packaged into the so called profile library. For example, the
Boost profile implementation is provided by the libodb-boost
profile library.

Besides linking the profile library to our application, it is also
necessary to let the ODB compiler know which profiles we
are using. This is accomplished with the --profile
(or -p alias) option. For example:


odb --profile boost ...


Some profiles, especially those covering frameworks or libraries that
consist of multiple sub-libraries, provide sub-profiles that allow you
to pick and choose which components you would like to use in your
application. For example, the boost profile contains
the boost/data-time sub-profile. If we are only
interested in the date_time types, then we can
pass boost/data-time instead of boost
to the --profile option, for example:


odb --profile boost/date-time ...


To summarize, you will need to perform the following steps in order
to make use of a profile in your application:


ODB compiler: if necessary, specify the path to the profile library
headers (-I option).
ODB compiler: specify the profile you would like to use with
the --profile option.
C++ compiler: if necessary, specify the path to the profile library
headers (normally -I option).
Linker: link the profile library to the application.


The remaining chapters in this part of the manual describe the
standard profiles provided by ODB.






21 Boost Profile

The ODB profile implementation for Boost is provided by the
libodb-boost library and consists of multiple sub-profiles
corresponding to the individual Boost libraries. To enable all the
available Boost sub-profiles, pass boost as the profile
name to the --profile ODB compiler option. Alternatively,
you can enable only specific sub-profiles by passing individual
sub-profile names to --profile. The following sections in
this chapter discuss each Boost sub-profile in detail. The
boost example in the odb-examples
package shows how to enable and use the Boost profile.

Some sub-profiles may throw exceptions to indicate error conditions,
such as the inability to store a specific value in a particular database
system. All such exceptions derive from the
odb::boost::exception class which in turn derives from
the root of the ODB exception hierarchy, class odb::exception
(Section 3.14, "ODB Exceptions"). The
odb::boost::exception class is defined in the
<odb/boost/exception.hxx> header file and has the
same interface as odb::exception. The concrete exceptions
that can be thrown by the Boost sub-profiles are described in the
following sections.

21.1 Smart Pointers Library

The smart-ptr sub-profile provides persistence
support for a subset of smart pointers from the Boost
smart_ptr library. To enable only this profile,
pass boost/smart-ptr to the --profile
ODB compiler option.

The currently supported smart pointers are
boost::shared_ptr and boost::weak_ptr. For
more information on using smart pointers as pointers to objects and
views, refer to Section 3.3, "Object and View Pointers"
and Chapter 6, "Relationships". For more information
on using smart pointers as pointers to values, refer to
Section 7.3, "Pointers and NULL Value
Semantics". When used as a pointer to a value, only
boost::shared_ptr is supported. For example:


#pragma db object
class person
{
...

#pragma db null
boost::shared_ptr<std::string> middle_name_;
};


To provide finer grained control over object relationship loading,
the smart-ptr sub-profile also provides the lazy
counterparts for the above pointers: odb::boost::lazy_shared_ptr and
odb::boost::lazy_weak_ptr. You will need to include the
<odb/boost/lazy-ptr.hxx> header file to make the lazy
variants available in your application. For the description of the lazy
pointer interface and semantics refer to Section 6.4,
"Lazy Pointers". The following example shows how we can use these
smart pointers to establish a relationship between persistent objects.


class employee;

#pragma db object
class position
{
...

#pragma db inverse(position_)
odb::boost::lazy_weak_ptr<employee> employee_;
};

#pragma db object
class employee
{
...

#pragma db not_null
boost::shared_ptr<position> position_;
};


Besides providing persistence support for the above smart pointers,
the smart-ptr sub-profile also changes the default
pointer (Section 3.3, "Object and View Pointers")
to boost::shared_ptr. In particular, this means that
database functions that return dynamically allocated objects and views
will return them as boost::shared_ptr pointers. To override
this behavior, add the --default-pointer option specifying
the alternative pointer type after the --profile option.

21.2 Unordered Containers Library

The unordered sub-profile provides persistence support for
the containers from the Boost unordered library. To enable
only this profile, pass boost/unordered to
the --profile ODB compiler option.

The supported containers are boost::unordered_set,
boost::unordered_map, boost::unordered_multiset,
and boost::unordered_multimap. For more information on using
the set and multiset containers with ODB refer to Section
5.2, "Set and Multiset Containers". For more information on using the
map and multimap containers with ODB refer to Section
5.3, "Map and Multimap Containers". The following example shows how
the unordered_set container may be used within a persistent
object.


#pragma db object
class person
{
...
boost::unordered_set<std::string> emails_;
};


21.3 Multi-Index Container Library

The multi-index sub-profile provides persistence support for
boost::multi_index_container from the Boost Multi-Index
library. To enable only this profile, pass boost/multi-index
to the --profile ODB compiler option. The following example
shows how multi_index_container may be used within a
persistent object.


namespace mi = boost::multi_index;

#pragma db object
class person
{
...

typedef
mi::multi_index_container<
std::string,
mi::indexed_by<
mi::sequenced<>,
mi::ordered_unique<mi::identity<std::string> >
>
> emails;

emails emails_;
};


Note that a multi_index_container instantiation is
stored differently in the database depending on whether it has
any sequenced or random_access indexes.
If it does, then it is treated as an ordered container
(Section 5.1, "Ordered Containers") with the
first such index establishing the order. Otherwise, it is treated
as a set container (Section 5.2, "Set and Multiset
Containers").

Note also that there is a terminology clash between ODB and Boost
Multi-Index. The ODB term ordered container translates
to Multi-Index terms sequenced index and random access
index while the ODB term set container translates
to Multi-Index terms ordered index and hashed
index.

The emails container from the above example is stored
as an ordered container. In contrast, the following aliases
container is stored as a set.


namespace mi = boost::multi_index;

#pragma db value
struct name
{
std::string first;
std::string last;
};

bool operator< (const name&, const name&);

#pragma db object
class person
{
...

typedef
mi::multi_index_container<
name,
mi::indexed_by<
mi::ordered_unique<mi::identity<name> >
mi::ordered_non_unique<
mi::member<name, std::string, &name::first>
>,
mi::ordered_non_unique<
mi::member<name, std::string, &name::last>
>
>
> aliases;

aliases aliases_;
};


21.4 Optional Library

The optional sub-profile provides persistence support for
the boost::optional container from the Boost
optional library. To enable only this profile, pass
boost/optional to the --profile ODB compiler
option.

In a relational database boost::optional is mapped to
a column that can have a NULL value. Similar to
odb::nullable (Section 7.3, "Pointers and
NULL Value Semantics"), it can be used to add the
NULL semantics to existing C++ types. For example:


#include <boost/optional.hpp>

#pragma db object
class person
{
...

std::string first_; // TEXT NOT NULL
boost::optional<std::string> middle_; // TEXT NULL
std::string last_; // TEXT NOT NULL
};


Note also that similar to odb::nullable, when
this profile is used, the NULL values are automatically
enabled for data members of the boost::optional type.

21.5 Date Time Library

The date-time sub-profile provides persistence support for a
subset of types from the Boost date_time library. It is
further subdivided into two sub-profiles, gregorian
and posix_time. The gregorian sub-profile
provides support for types from the boost::gregorian
namespace, while the posix-time sub-profile provides support
for types from the boost::posix_time namespace. To enable
the entire date-time sub-profile, pass
boost/date-time to the --profile ODB compiler
option. To enable only the gregorian sub-profile, pass
boost/date-time/gregorian, and to enable only the
posix-time sub-profile, pass
boost/date-time/posix-time.

The only type that the gregorian sub-profile currently
supports is gregorian::date. The types currently supported
by the posix-time sub-profile are
posix_time::ptime and
posix_time::time_duration. The manner in which these types
are persisted is database system dependent and is discussed in the
sub-sections that follow. The example below shows how
gregorian::date may be used within a persistent object.


#pragma db object
class person
{
...
boost::gregorian::date date_of_birth_;
};


The concrete exceptions that can be thrown by the date-time
sub-profile implementation are presented below.



namespace odb
{
namespace boost
{
namespace date_time
{
struct special_value: odb::boost::exception
{
virtual const char*
what () const throw ();
};

struct value_out_of_range: odb::boost::exception
{
virtual const char*
what () const throw ();
};
}
}
}


You will need to include the
<odb/boost/date-time/exceptions.hxx> header file to
make these exceptions available in your application.

The special_value exception is thrown if an attempt is made
to store a Boost date-time special value that cannot be represented in
the target database. The value_out_of_range exception is
thrown if an attempt is made to store a date-time value that is out of
the target database range. The specific conditions under which these
exceptions are thrown are database system dependent and are discussed in
more detail in the following sub-sections.

21.5.1 MySQL Database Type Mapping

The following table summarizes the default mapping between the currently
supported Boost date_time types and the MySQL database
types.




Boost date_time Type
MySQL Type
Default NULL Semantics



gregorian::date
DATE
NULL



posix_time::ptime
DATETIME
NULL



posix_time::time_duration
TIME
NULL



The Boost special value date_time::not_a_date_time is stored
as a NULL value in a MySQL database.

The posix-time sub-profile implementation also provides
support for mapping posix_time::ptime to the
TIMESTAMP MySQL type. However, this mapping has to be
explicitly requested using the db type pragma
(Section 12.4.3, "type"), as shown in
the following example:


#pragma db object
class person
{
...
#pragma db type("TIMESTAMP") not_null
boost::posix_time::ptime updated_;
};


Some valid Boost date-time values cannot be stored in a MySQL database.
An attempt to persist any Boost date-time special value other than
date_time::not_a_date_time will result in the
special_value exception. An attempt to persist a Boost
date-time value that is out of the MySQL type range will result in
the out_of_range exception. Refer to the MySQL
documentation for more information on the MySQL data type ranges.

21.5.2 SQLite Database Type Mapping

The following table summarizes the default mapping between the currently
supported Boost date_time types and the SQLite database
types.




Boost date_time Type
SQLite Type
Default NULL Semantics



gregorian::date
TEXT
NULL



posix_time::ptime
TEXT
NULL



posix_time::time_duration
TEXT
NULL



The Boost special value date_time::not_a_date_time is stored
as a NULL value in an SQLite database.

The date-time sub-profile implementation also provides
support for mapping gregorian::date and
posix_time::ptime to the INTEGER SQLite type,
with the integer value representing the UNIX time. Similarly, an
alternative mapping for posix_time::time_duration to the
INTEGER type represents the duration as a number of
seconds. These mappings have to be explicitly requested using the
db type pragma (Section 12.4.3,
"type"), as shown in the following example:


#pragma db object
class person
{
...
#pragma db type("INTEGER")
boost::gregorian::date born_;
};




Some valid Boost date-time values cannot be stored in an SQLite database.
An attempt to persist any Boost date-time special value other than
date_time::not_a_date_time will result in the
special_value exception. An attempt to persist a negative
posix_time::time_duration value as SQLite TEXT
will result in the out_of_range exception.


21.5.3 PostgreSQL Database Type Mapping

The following table summarizes the default mapping between the currently
supported Boost date_time types and the PostgreSQL database
types.




Boost date_time Type
PostgreSQL Type
Default NULL Semantics



gregorian::date
DATE
NULL



posix_time::ptime
TIMESTAMP
NULL



posix_time::time_duration
TIME
NULL



The Boost special value date_time::not_a_date_time is stored
as a NULL value in a PostgreSQL database.
posix_time::ptime values representing the special values
date_time::pos_infin and date_time::neg_infin
are stored as the special PostgreSQL TIMESTAMP values
infinity and -infinity, respectively.

Some valid Boost date-time values cannot be stored in a PostgreSQL
database. The PostgreSQL TIME type represents a clock time, and can
therefore only store positive durations with a total length of time less
than 24 hours. An attempt to persist a
posix_time::time_duration value outside of this range will
result in the value_out_of_range exception. An attempt to
persist a posix_time::time_duration value representing any
special value other than date_time::not_a_date_time will
result in the special_value exception.


21.5.4 Oracle Database Type Mapping

The following table summarizes the default mapping between the currently
supported Boost date_time types and the Oracle database
types.




Boost date_time Type
Oracle Type
Default NULL Semantics



gregorian::date
DATE
NULL



posix_time::ptime
TIMESTAMP
NULL



posix_time::time_duration
INTERVAL DAY TO SECOND
NULL



The Boost special value date_time::not_a_date_time is stored
as a NULL value in an Oracle database.

The date-time sub-profile implementation also provides
support for mapping posix_time::ptime to the
DATE Oracle type with fractional seconds that may be
stored in a ptime instance being ignored. This
alternative mapping has to be explicitly requested using the
db type pragma (Section 12.4.3,
"type"), as shown in the following example:


#pragma db object
class person
{
...
#pragma db type("DATE")
boost::posix_time::ptime updated_;
};


Some valid Boost date-time values cannot be stored in an Oracle database.
An attempt to persist a gregorian::date,
posix_time::ptime, or
posix_time::time_duration value representing any special
value other than date_time::not_a_date_time will result in
the special_value exception.


21.5.5 SQL Server Database Type Mapping

The following table summarizes the default mapping between the currently
supported Boost date_time types and the SQL Server database
types.




Boost date_time Type
SQL Server Type
Default NULL Semantics



gregorian::date
DATE
NULL



posix_time::ptime
DATETIME2
NULL



posix_time::time_duration
TIME
NULL



The Boost special value date_time::not_a_date_time is stored
as a NULL value in an SQL Server database.

Note that the DATE, TIME, and
DATETIME2 types are only available in SQL Server 2008 and
later. SQL Server 2005 only supports the DATETIME and
SMALLDATETIME date-time types. The new types are
also unavailable when connecting to an SQL Server 2008 or
later with the SQL Server 2005 Native Client ODBC driver.

The date-time sub-profile implementation provides
support for mapping posix_time::ptime to the
DATETIME and SMALLDATETIME types,
however, this mapping has to be explicitly requested using the
db type pragma (Section 12.4.3,
"type"), as shown in the following example:


#pragma db object
class person
{
...
#pragma db type("DATETIME")
boost::posix_time::ptime updated_;
};


Some valid Boost date-time values cannot be stored in an SQL Server
database. An attempt to persist a gregorian::date,
posix_time::ptime, or posix_time::time_duration
value representing any special value other than
date_time::not_a_date_time will result in the
special_value exception. The range of the TIME
type in SQL server is from 00:00:00.0000000 to
23:59:59.9999999. An attempt to persist a
posix_time::time_duration value out of this range will
result in the value_out_of_range exception.

21.6 Uuid Library

The uuid sub-profile provides persistence support for the
uuid type from the Boost uuid library. To
enable only this profile, pass boost/uuid to the
--profile ODB compiler option.

The manner in which these types are persisted is database system
dependent and is discussed in the sub-sections that follow. By
default a data member of the uuid type is mapped to a
database column with NULL enabled and nil uuid
instances are stored as a NULL value. However, you can
change this behavior by declaring the data member NOT NULL
with the not_null pragma (Section
12.4.6, "null/not_null"). In this
case, or if the data member is an object id, the implementation
will store nil uuid instances as zero UUID values
({00000000-0000-0000-0000-000000000000}). For example:


#pragma db object
class object
{
...

boost::uuids::uuid x_; // Nil values stored as NULL.

#pragma db not_null
boost::uuids::uuid y_; // Nil values stored as zero.
};


21.6.1 MySQL Database Type Mapping

The following table summarizes the default mapping between the Boost
uuid type and the MySQL database type.




Boost Type
MySQL Type
Default NULL Semantics



boost::uuids::uuid
BINARY(16)
NULL



21.6.2 SQLite Database Type Mapping

The following table summarizes the default mapping between the Boost
uuid type and the SQLite database type.




Boost Type
SQLite Type
Default NULL Semantics



boost::uuids::uuid
BLOB
NULL



21.6.3 PostgreSQL Database Type Mapping

The following table summarizes the default mapping between the Boost
uuid type and the PostgreSQL database type.




Boost Type
PostgreSQL Type
Default NULL Semantics



boost::uuids::uuid
UUID
NULL



21.6.4 Oracle Database Type Mapping

The following table summarizes the default mapping between the Boost
uuid type and the Oracle database type.




Boost Type
Oracle Type
Default NULL Semantics



boost::uuids::uuid
RAW(16)
NULL



21.6.5 SQL Server Database Type Mapping

The following table summarizes the default mapping between the Boost
uuid type and the SQL Server database type.




Boost Type
SQL Server Type
Default NULL Semantics



boost::uuids::uuid
UNIQUEIDENTIFIER
NULL








22 Qt Profile

The ODB profile implementation for Qt is provided by the
libodb-qt library. Both Qt4 and Qt5 as well
as C++98/03 and C++11 are supported.

The Qt profile consists of multiple sub-profiles
corresponding to the common type groups within Qt. Currently,
only types from the QtCore module are supported. To
enable all the available Qt sub-profiles, pass qt as the
profile name to the --profile ODB compiler option.
Alternatively, you can enable only specific sub-profiles by passing
individual sub-profile names to --profile. The following
sections in this chapter discuss each Qt sub-profile in detail. The
qt example in the odb-examples
package shows how to enable and use the Qt profile.

Some sub-profiles may throw exceptions to indicate error conditions,
such as the inability to store a specific value in a particular database
system. All such exceptions derive from the
odb::qt::exception class which in turn derives from
the root of the ODB exception hierarchy, class odb::exception
(Section 3.14, "ODB Exceptions"). The
odb::qt::exception class is defined in the
<odb/qt/exception.hxx> header file and has the
same interface as odb::exception. The concrete exceptions
that can be thrown by the Qt sub-profiles are described in the
following sections.

22.1 Basic Types Library

The basic sub-profile provides persistence support for basic
types defined by Qt. To enable only this profile, pass
qt/basic to the --profile ODB compiler
option.

The currently supported basic types are QString,
QByteArray, and QUuid. The manner in
which these types are persisted is database system dependent
and is discussed in the sub-sections that follow. The example
below shows how QString may be used within a
persistent object.


#pragma db object
class Person
{
...
QString name_;
};


By default a data member of the QUuid type is mapped to a
database column with NULL enabled and null QUuid
instances are stored as a NULL value. However, you can
change this behavior by declaring the data member NOT NULL
with the not_null pragma (Section
12.4.6, "null/not_null"). In this
case, or if the data member is an object id, the implementation
will store null QUuid instances as zero UUID values
({00000000-0000-0000-0000-000000000000}). For example:


#pragma db object
class object
{
...

QUuid x_; // Null values stored as NULL.

#pragma db not_null
QUuid y_; // Null values stored as zero.
};


22.1.1 MySQL Database Type Mapping

The following table summarizes the default mapping between the currently
supported basic Qt types and the MySQL database types.




Qt Type
MySQL Type
Default NULL Semantics



QString
TEXT/VARCHAR(255)
NULL



QByteArray
BLOB
NULL



QUuid
BINARY(16)
NULL



Instances of the QString and QByteArray
types are stored as a NULL value if their isNull()
member function returns true.

Note also that the QString type is mapped
differently depending on whether a member of this type
is an object id or not. If the member is an object id,
then for this member QString is mapped
to the VARCHAR(255) MySQL type. Otherwise,
it is mapped to TEXT.

The basic sub-profile also provides support
for mapping QString to the CHAR,
NCHAR, and NVARCHAR MySQL types.
However, these alternative mappings have to be explicitly
requested using the db type pragma
(Section 12.4.3, "type"), as shown in
the following example:


#pragma db object
class Person
{
...

#pragma db type("CHAR(2)") not_null
QString licenseState_;
};



22.1.2 SQLite Database Type Mapping

The following table summarizes the default mapping between the currently
supported basic Qt types and the SQLite database types.




Qt Type
SQLite Type
Default NULL Semantics



QString
TEXT
NULL



QByteArray
BLOB
NULL



QUuid
BLOB
NULL



Instances of the QString and QByteArray types
are stored as a NULL value if their isNull() member
function returns true.

22.1.3 PostgreSQL Database Type Mapping

The following table summarizes the default mapping between the currently
supported basic Qt types and the PostgreSQL database types.




Qt Type
PostgreSQL Type
Default NULL Semantics



QString
TEXT
NULL



QByteArray
BYTEA
NULL



QUuid
UUID
NULL



Instances of the QString and QByteArray types
are stored as a NULL value if their isNull() member
function returns true.

The basic sub-profile also provides support
for mapping QString to the CHAR
and VARCHAR PostgreSQL types.
However, these alternative mappings have to be explicitly
requested using the db type pragma
(Section 12.4.3, "type"), as shown in
the following example:


#pragma db object
class Person
{
...

#pragma db type("CHAR(2)") not_null
QString licenseState_;
};


22.1.4 Oracle Database Type Mapping

The following table summarizes the default mapping between the currently
supported basic Qt types and the Oracle database types.




Qt Type
Oracle Type
Default NULL Semantics



QString
VARCHAR2(512)
NULL



QByteArray
BLOB
NULL



QUuid
RAW(16)
NULL



Instances of the QString and QByteArray types
are stored as a NULL value if their isNull() member
function returns true.

The basic sub-profile also provides support
for mapping QString to the CHAR,
NCHAR, NVARCHAR, CLOB, and
NCLOB Oracle types, and for mapping QByteArray
to the RAW Oracle type. However, these alternative
mappings have to be explicitly requested using the db type
pragma (Section 12.4.3, "type"), as shown in the
following example:


#pragma db object
class Person
{
...

#pragma db type("CLOB") not_null
QString firstName_;

#pragma db type("RAW(16)") null
QByteArray uuid_;
};


22.1.5 SQL Server Database Type Mapping

The following table summarizes the default mapping between the currently
supported basic Qt types and the SQL Server database types.




Qt Type
SQL Server Type
Default NULL Semantics



QString
VARCHAR(512)/VARCHAR(256)
NULL



QByteArray
VARBINARY(max)
NULL



QUuid
UNIQUEIDENTIFIER
NULL



Instances of the QString and QByteArray types
are stored as a NULL value if their isNull() member
function returns true.

Note also that the QString type is mapped
differently depending on whether a member of this type
is an object id or not. If the member is an object id,
then for this member QString is mapped
to the VARCHAR(256) SQL Server type. Otherwise,
it is mapped to VARCHAR(512).

The basic sub-profile also provides support
for mapping QString to the CHAR,
NCHAR, NVARCHAR, TEXT, and
NTEXT SQL Server types, and for mapping
QByteArray to the BINARY and
IMAGE SQL Server types. However, these alternative
mappings have to be explicitly requested using the db type
pragma (Section 12.4.3, "type"), as shown in the
following example:


#pragma db object
class Person
{
...

#pragma db type("NVARCHAR(256)") not_null
QString firstName_;

#pragma db type("BINARY(16)") null
QByteArray uuid_;
};


22.2 Smart Pointers Library

The smart-ptr sub-profile provides persistence support the
Qt smart pointers. To enable only this profile, pass
qt/smart-ptr to the --profile ODB compiler
option.

The currently supported smart pointers are
QSharedPointer and QWeakPointer.
For more information on using smart pointers as pointers to objects
and views, refer to Section 3.3, "Object and View
Pointers" and Chapter 6, "Relationships". For
more information on using smart pointers as pointers to values, refer
to Section 7.3, "Pointers and NULL Value
Semantics". When used as a pointer to a value, only
QSharedPointer is supported. For example:


#pragma db object
class person
{
...

#pragma db null
QSharedPointer<QString> middle_name_;
};


To provide finer grained control over object relationship loading,
the smart-ptr sub-profile also provides the lazy
counterparts for the above pointers: QLazySharedPointer
and QLazyWeakPointer. You will need to include the
<odb/qt/lazy-ptr.hxx> header file to make the lazy
variants available in your application. For the description of the lazy
pointer interface and semantics refer to Section 6.4,
"Lazy Pointers". The following example shows how we can use these
smart pointers to establish a relationship between persistent objects.


class Employee;

#pragma db object
class Position
{
...

#pragma db inverse(position_)
QLazyWeakPointer<Employee> employee_;
};

#pragma db object
class Employee
{
...

#pragma db not_null
QSharedPointer<Position> position_;
};


Besides providing persistence support for the above smart pointers,
the smart-ptr sub-profile also changes the default
pointer (Section 3.3, "Object and View Pointers")
to QSharedPointer. In particular, this means that
database functions that return dynamically allocated objects and views
will return them as QSharedPointer pointers. To override
this behavior, add the --default-pointer option specifying
the alternative pointer type after the --profile option.

22.3 Containers Library

The containers sub-profile provides persistence support for
Qt containers. To enable only this profile, pass
qt/containers to the --profile ODB compiler
option.

The currently supported ordered containers are QVector,
QList, and QLinkedList. Supported map
containers are QMap, QMultiMap,
QHash, and QMultiHash. The supported set
container is QSet. For more information on using
containers with ODB refer to Chapter 5, "Containers".
The following example shows how the QSet container may
be used within a persistent object.


#pragma db object
class Person
{
...
QSet<QString> emails_;
};


The containers sub-profile also provide a change-tracking
equivalent for QList (Section 22.3.1,
"Change-Tracking QList") with support for other Qt
container equivalents planned for future releases. For general information
on change-tracking containers refer to Section 5.4,
"Change-Tracking Containers".

22.3.1 Change-Tracking QList

Class template QOdbList, defined in
<odb/qt/list.hxx>, is a change-tracking
equivalent for QList. It
is implemented in terms of QList and is
implicit-convertible to and implicit-constructible from
const QList&. In particular, this
means that we can use QOdbList instance
anywhere const QList& is
expected. In addition, QOdbList constant
iterator (const_iterator) is the same type as
that of QList.

QOdbList incurs 2-bit per element overhead
in order to store the change state. It cannot
be stored unordered in the database (Section
12.4.18 "unordered") but can be used as an inverse
side of a relationship (6.2 "Bidirectional
Relationships"). In this case, no change tracking is performed
since no state for such a container is stored in the database.

The number of database operations required to update the state
of QOdbList corresponds well to the complexity
of QList functions, except for
prepend()/push_front(). In particular, adding
or removing an element from the back of the list (for example,
with append()/push_back() and
removeLast()/pop_back()),
requires only a single database statement execution. In contrast,
inserting or erasing an element at the beginning or in the middle
of the list will require a database statement for every element that
follows it.

QOdbList replicates most of the QList
interface as defined in both Qt4 and Qt5 and includes support for
C++11. However, functions and operators that provide direct write
access to the elements had to be altered or disabled in order to
support change tracking. Additional functions used to interface with
QList and to control the change tracking state
were also added. The following listing summarizes the differences
between the QOdbList and QList
interfaces. Any QList function or operator
not mentioned in this listing has exactly the same signature
and semantics in QOdbList. Functions and
operators that were disabled are shown as commented out and
are followed by functions/operators that replace them.


template <typename T>
class QOdbList
{
...

// Element access.
//

//T& operator[] (int);
T& modify (int);

//T& first();
T& modifyFirst();

//T& last();
T& modifyLast();

//T& front();
T& modify_front();

//T& back();
T& modify_back();

// Iterators.
//
typedef typename QList<T>::const_iterator const_iterator;

class iterator
{
...

// Element Access.
//

//reference operator* () const;
const_reference operator* () const;
reference modify () const;

//pointer operator-> () const;
const_pointer operator-> () const;

//reference operator[] (difference_type);
const_reference operator[] (difference_type);
reference modify (difference_type) const;

// Interfacing with QList::iterator.
//
typename QList<T>::iterator base () const;
};

// Return QList iterators. The begin() functions mark all
// the elements as modified.
//
typename QList<T>::iterator mbegin ();
typename QList<T>::iterator modifyBegin ();
typename QList<T>::iterator mend ();
typename QList<T>::iterator modifyEnd ();

// Interfacing with QList.
//
QOdbList (const QList<T>&);
QOdbList (QList<T>&&); // C++11 only.

QOdbList& operator= (const QList<T>&);
QOdbList& operator= (QList<T>&&);

operator const QList<T>& () const;
QList<T>& base ();
const QList<T>& base () const;

// Change tracking.
//
bool _tracking () const;
void _start () const;
void _stop () const;
void _arm (transaction&) const;
};


The following example highlights some of the differences between
the two interfaces. QList versions are commented
out.


#include <QtCore/QList>
#include <odb/qt/list.hxx>

void f (const QList<int>&);

QOdbList<int> l ({1, 2, 3});

f (l); // Ok, implicit conversion.

if (l[1] == 2) // Ok, const access.
//l[1]++;
l.modify (1)++;

//l.last () = 4;
l.modifyLast () = 4;

for (auto i (l.begin ()); i != l.end (); ++i)
{
if (*i != 0) // Ok, const access.
//*i += 10;
i.modify () += 10;
}

qSort (l.modifyBegin (), l.modifyEnd ());


Note also the subtle difference between copy/move construction
and copy/move assignment of QOdbList instances.
While copy/move constructor will copy/move both the elements as
well as their change state, in contrast, assignment is tracked
as any other change to the vector content.

The QListIterator and QMutableListIterator
equivalents are also provided. These are QOdbListIterator
and QMutableOdbListIterator and are defined in
<odb/qt/list-iterator.hxx> and
<odb/qt/mutable-list-iterator.hxx>, respectively.

QOdbListIterator has exactly the same interface and
semantics as QListIterator. In fact, we can use
QListIterator to iterate over a QOdbList
instance.

QMutableOdbListIterator also has exactly the same
interface as QMutableListIterator. Note, however,
that any element that such an iterator passes over with the
call to next() is marked as modified.

22.4 Date Time Library

The date-time sub-profile provides persistence support for
the Qt date-time types. To enable only this profile, pass
qt/date-time to the --profile ODB compiler
option.

The currently supported date-time types are QDate,
QTime, and QDateTime. The manner in which
these types are persisted is database system dependent and is
discussed in the sub-sections that follow. The example below shows how
QDate may be used within a persistent object.


#pragma db object
class Person
{
...
QDate dateOfBirth_;
};


The single concrete exception that can be thrown by the
date-time sub-profile implementation is presented below.



namespace odb
{
namespace qt
{
namespace date_time
{
struct value_out_of_range: odb::qt::exception
{
virtual const char*
what () const throw ();
};
}
}
}


You will need to include the
<odb/qt/date-time/exceptions.hxx> header file to
make this exception available in your application.

The value_out_of_range exception is thrown if an attempt
is made to store a date-time value that is out of the target database
range. The specific conditions under which it is thrown is database
system dependent and is discussed in more detail in the
following sub-sections.

22.4.1 MySQL Database Type Mapping

The following table summarizes the default mapping between the currently
supported Qt date-time types and the MySQL database types.




Qt Date Time Type
MySQL Type
Default NULL Semantics



QDate
DATE
NULL



QTime
TIME
NULL



QDateTime
DATETIME
NULL



Instances of the QDate, QTime, and
QDateTime types are stored as a NULL value if their
isNull() member function returns true.

The date-time sub-profile implementation also provides
support for mapping QDateTime to the TIMESTAMP
MySQL type. However, this mapping has to be explicitly requested using
the db type pragma
(Section 12.4.3, "type"), as shown in
the following example:


#pragma db object
class Person
{
...
#pragma db type("TIMESTAMP") not_null
QDateTime updated_;
};


Some valid Qt date-time values cannot be stored in a MySQL database. An
attempt to persist a Qt date-time value that is out of the MySQL type
range will result in the out_of_range exception. Refer to
the MySQL documentation for more information on the MySQL data type
ranges.

22.4.2 SQLite Database Type Mapping

The following table summarizes the default mapping between the currently
supported Qt date-time types and the SQLite database types.




Qt Date Time Type
SQLite Type
Default NULL Semantics



QDate
TEXT
NULL



QTime
TEXT
NULL



QDateTime
TEXT
NULL



Instances of the QDate, QTime, and
QDateTime types are stored as a NULL value if their
isNull() member function returns true.

The date-time sub-profile implementation also provides
support for mapping QDate and QDateTime to the
SQLite INTEGER type, with the integer value representing the
UNIX time. Similarly, an alternative mapping for QTime to
the INTEGER type represents a clock time as the number of
seconds since midnight. These mappings have to be explicitly requested
using the db type pragma
(Section 12.4.3, "type"), as shown
in the following example:


#pragma db object
class Person
{
...
#pragma db type("INTEGER")
QDate born_;
};


Some valid Qt date-time values cannot be stored in an SQLite database.
An attempt to persist any Qt date-time value representing a negative UNIX
time (any point in time prior to the 1970-01-01 00:00:00 UNIX time
epoch) as an SQLite INTEGER will result in the
out_of_range exception.

22.4.3 PostgreSQL Database Type Mapping

The following table summarizes the default mapping between the currently
supported Qt date-time types and the PostgreSQL database types.




Qt Date Time Type
PostgreSQL Type
Default NULL Semantics



QDate
DATE
NULL



QTime
TIME
NULL



QDateTime
TIMESTAMP
NULL



Instances of the QDate, QTime, and
QDateTime types are stored as a NULL value if their
isNull() member function returns true.

22.4.4 Oracle Database Type Mapping

The following table summarizes the default mapping between the currently
supported Qt date-time types and the Oracle database types.




Qt Date Time Type
Oracle Type
Default NULL Semantics



QDate
DATE
NULL



QTime
INTERVAL DAY(0) TO SECOND(3)
NULL



QDateTime
TIMESTAMP(3)
NULL



Instances of the QDate, QTime, and
QDateTime types are stored as a NULL value if their
isNull() member function returns true.

The date-time sub-profile implementation also provides
support for mapping QDateTime to the
DATE Oracle type with fractional seconds that may be
stored in a QDateTime instance being ignored. This
alternative mapping has to be explicitly requested using the
db type pragma (Section 12.4.3,
"type"), as shown in the following example:


#pragma db object
class person
{
...
#pragma db type("DATE")
QDateTime updated_;
};


22.4.5 SQL Server Database Type Mapping

The following table summarizes the default mapping between the currently
supported Qt date-time types and the SQL Server database types.




Qt Date Time Type
SQL Server Type
Default NULL Semantics



QDate
DATE
NULL



QTime
TIME(3)
NULL



QDateTime
DATETIME2(3)
NULL



Instances of the QDate, QTime, and
QDateTime types are stored as a NULL value if their
isNull() member function returns true.

Note that the DATE, TIME, and
DATETIME2 types are only available in SQL Server 2008 and
later. SQL Server 2005 only supports the DATETIME and
SMALLDATETIME date-time types. The new types are
also unavailable when connecting to an SQL Server 2008 or
later with the SQL Server 2005 Native Client ODBC driver.

The date-time sub-profile implementation provides
support for mapping QDateTime to the DATETIME
and SMALLDATETIME types, however, this mapping has to
be explicitly requested using the db type pragma
(Section 12.4.3, "type"), as
shown in the following example:


#pragma db object
class person
{
...
#pragma db type("DATETIME")
QDateTime updated_;
};