Make changes required for testtest

16 files changed, 37673 insertions, 0 deletions

diff --git a/libbrep/build-extra.hxx b/libbrep/build-extra.hxx
new file mode 100644
index 0000000..fd59069
--- /dev/null
+++ b/libbrep/build-extra.hxx
@@ -0,0 +1,288 @@
+  0x2d, 0x2d, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65,
+  0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x70,
+  0x61, 0x72, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x62, 0x79, 0x20, 0x74,
+  0x68, 0x65, 0x20, 0x62, 0x72, 0x65, 0x70, 0x2d, 0x6d, 0x69, 0x67, 0x72,
+  0x61, 0x74, 0x65, 0x20, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e,
+  0x20, 0x54, 0x6f, 0x20, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65,
+  0x20, 0x74, 0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x70, 0x61, 0x72, 0x73,
+  0x65, 0x72, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x69, 0x74,
+  0x79, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20,
+  0x61, 0x20, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x6f, 0x66, 0x20,
+  0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+  0x2c, 0x20, 0x73, 0x65, 0x65, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x2d, 0x65, 0x78, 0x74, 0x72, 0x61, 0x2e, 0x73, 0x71, 0x6c, 0x0a,
+  0x2d, 0x2d, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20,
+  0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a,
+  0x2d, 0x2d, 0x20, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74,
+  0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73,
+  0x65, 0x20, 0x27, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x27, 0x20, 0x73, 0x63,
+  0x68, 0x65, 0x6d, 0x61, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x20, 0x77, 0x68, 0x65, 0x6e, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65,
+  0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2c, 0x20,
+  0x73, 0x65, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61,
+  0x67, 0x65, 0x2d, 0x65, 0x78, 0x74, 0x72, 0x61, 0x2e, 0x73, 0x71, 0x6c,
+  0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x64, 0x65,
+  0x74, 0x61, 0x69, 0x6c, 0x73, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x0a, 0x44,
+  0x52, 0x4f, 0x50, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x20,
+  0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58, 0x49,
+  0x53, 0x54, 0x53, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72,
+  0x61, 0x69, 0x6e, 0x74, 0x73, 0x3b, 0x0a, 0x0a, 0x44, 0x52, 0x4f, 0x50,
+  0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x20, 0x54, 0x41, 0x42,
+  0x4c, 0x45, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53,
+  0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61,
+  0x67, 0x65, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x73, 0x3b, 0x0a, 0x0a,
+  0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e,
+  0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58,
+  0x49, 0x53, 0x54, 0x53, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x70,
+  0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x73,
+  0x3b, 0x0a, 0x0a, 0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x4f, 0x52, 0x45,
+  0x49, 0x47, 0x4e, 0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x49, 0x46,
+  0x20, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x20, 0x62, 0x75, 0x69, 0x6c,
+  0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x3b, 0x0a, 0x0a,
+  0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e,
+  0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58,
+  0x49, 0x53, 0x54, 0x53, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x72,
+  0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x3b, 0x0a, 0x0a,
+  0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e,
+  0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58,
+  0x49, 0x53, 0x54, 0x53, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x74,
+  0x65, 0x6e, 0x61, 0x6e, 0x74, 0x3b, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x54,
+  0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x20, 0x74,
+  0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x75, 0x69,
+  0x6c, 0x64, 0x5f, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x6f, 0x62,
+  0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x43, 0x52, 0x45,
+  0x41, 0x54, 0x45, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x20,
+  0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f,
+  0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x28, 0x0a, 0x20, 0x20, 0x69,
+  0x64, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e,
+  0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x61, 0x72, 0x63, 0x68, 0x69,
+  0x76, 0x65, 0x64, 0x20, 0x42, 0x4f, 0x4f, 0x4c, 0x45, 0x41, 0x4e, 0x20,
+  0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x29, 0x0a, 0x53, 0x45,
+  0x52, 0x56, 0x45, 0x52, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
+  0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4f, 0x50, 0x54, 0x49,
+  0x4f, 0x4e, 0x53, 0x20, 0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6e,
+  0x61, 0x6d, 0x65, 0x20, 0x27, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x27,
+  0x29, 0x3b, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66,
+  0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65,
+  0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x72,
+  0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x6f, 0x62,
+  0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x43, 0x52, 0x45,
+  0x41, 0x54, 0x45, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x20,
+  0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f,
+  0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x20, 0x28,
+  0x0a, 0x20, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45,
+  0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c,
+  0x0a, 0x20, 0x20, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c,
+  0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e,
+  0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x6c,
+  0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x75, 0x72, 0x6c, 0x20,
+  0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c,
+  0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f,
+  0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20,
+  0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20,
+  0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x5f,
+  0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x20,
+  0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x29, 0x0a, 0x53,
+  0x45, 0x52, 0x56, 0x45, 0x52, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4f, 0x50, 0x54,
+  0x49, 0x4f, 0x4e, 0x53, 0x20, 0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f,
+  0x6e, 0x61, 0x6d, 0x65, 0x20, 0x27, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69,
+  0x74, 0x6f, 0x72, 0x79, 0x27, 0x29, 0x3b, 0x0a, 0x0a, 0x2d, 0x2d, 0x20,
+  0x54, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e, 0x20,
+  0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x62, 0x75,
+  0x69, 0x6c, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20,
+  0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x43,
+  0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47,
+  0x4e, 0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x62, 0x75, 0x69, 0x6c,
+  0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x28, 0x0a,
+  0x20, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58,
+  0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a,
+  0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x49, 0x54, 0x45, 0x58,
+  0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a,
+  0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70,
+  0x6f, 0x63, 0x68, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x20,
+  0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f,
+  0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65,
+  0x61, 0x6d, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20,
+  0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61,
+  0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x54, 0x45,
+  0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20,
+  0x43, 0x4f, 0x4c, 0x4c, 0x41, 0x54, 0x45, 0x20, 0x22, 0x43, 0x22, 0x2c,
+  0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72,
+  0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x4e, 0x54, 0x45,
+  0x47, 0x45, 0x52, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c,
+  0x2c, 0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+  0x75, 0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x54, 0x45, 0x58,
+  0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a,
+  0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65,
+  0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e,
+  0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72,
+  0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f,
+  0x72, 0x79, 0x5f, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45,
+  0x58, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x69,
+  0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x70, 0x6f,
+  0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e,
+  0x69, 0x63, 0x61, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x54, 0x45,
+  0x58, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x62,
+  0x75, 0x69, 0x6c, 0x64, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x42, 0x4f, 0x4f,
+  0x4c, 0x45, 0x41, 0x4e, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c,
+  0x4c, 0x29, 0x0a, 0x53, 0x45, 0x52, 0x56, 0x45, 0x52, 0x20, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
+  0x20, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x20, 0x28, 0x74, 0x61,
+  0x62, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x27, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x27, 0x29, 0x3b, 0x0a, 0x0a, 0x2d, 0x2d,
+  0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x65, 0x69, 0x67, 0x6e,
+  0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74,
+  0x68, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x70, 0x61, 0x63,
+  0x6b, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x20,
+  0x74, 0x65, 0x73, 0x74, 0x73, 0x20, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72,
+  0x20, 0x28, 0x74, 0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x20, 0x6f, 0x66,
+  0x20, 0x61, 0x0a, 0x2d, 0x2d, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69,
+  0x6e, 0x65, 0x72, 0x20, 0x74, 0x79, 0x70, 0x65, 0x29, 0x2e, 0x0a, 0x2d,
+  0x2d, 0x0a, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46, 0x4f, 0x52,
+  0x45, 0x49, 0x47, 0x4e, 0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x62,
+  0x75, 0x69, 0x6c, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
+  0x5f, 0x74, 0x65, 0x73, 0x74, 0x73, 0x20, 0x28, 0x0a, 0x20, 0x20, 0x74,
+  0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e,
+  0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x6e,
+  0x61, 0x6d, 0x65, 0x20, 0x43, 0x49, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e,
+  0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+  0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x20, 0x4e, 0x4f, 0x54,
+  0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x76, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63,
+  0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20,
+  0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c,
+  0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72,
+  0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20,
+  0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x43, 0x4f, 0x4c,
+  0x4c, 0x41, 0x54, 0x45, 0x20, 0x22, 0x43, 0x22, 0x2c, 0x0a, 0x20, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69,
+  0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52,
+  0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20,
+  0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x42, 0x49, 0x47, 0x49, 0x4e,
+  0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a,
+  0x20, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20,
+  0x43, 0x49, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e,
+  0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f,
+  0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x65, 0x6e, 0x61,
+  0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c,
+  0x2c, 0x0a, 0x20, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63,
+  0x6b, 0x61, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x49,
+  0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20,
+  0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70,
+  0x6f, 0x63, 0x68, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x20,
+  0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x74, 0x65, 0x73, 0x74,
+  0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63,
+  0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20,
+  0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20,
+  0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61,
+  0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65,
+  0x61, 0x73, 0x65, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x55, 0x4c,
+  0x4c, 0x20, 0x43, 0x4f, 0x4c, 0x4c, 0x41, 0x54, 0x45, 0x20, 0x22, 0x43,
+  0x22, 0x2c, 0x0a, 0x20, 0x20, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49,
+  0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x29,
+  0x0a, 0x53, 0x45, 0x52, 0x56, 0x45, 0x52, 0x20, 0x70, 0x61, 0x63, 0x6b,
+  0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4f,
+  0x50, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x20, 0x28, 0x74, 0x61, 0x62, 0x6c,
+  0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x27, 0x70, 0x61, 0x63, 0x6b,
+  0x61, 0x67, 0x65, 0x5f, 0x74, 0x65, 0x73, 0x74, 0x73, 0x27, 0x29, 0x3b,
+  0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72,
+  0x65, 0x69, 0x67, 0x6e, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66,
+  0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64,
+  0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x62, 0x6a,
+  0x65, 0x63, 0x74, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x73, 0x20, 0x6d,
+  0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x28, 0x74, 0x68, 0x61, 0x74, 0x20,
+  0x69, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x0a, 0x2d, 0x2d, 0x20, 0x63,
+  0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72, 0x20, 0x74, 0x79, 0x70,
+  0x65, 0x29, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x43, 0x52, 0x45, 0x41, 0x54,
+  0x45, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47, 0x4e, 0x20, 0x54, 0x41,
+  0x42, 0x4c, 0x45, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x73,
+  0x20, 0x28, 0x0a, 0x20, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20,
+  0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c,
+  0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x49,
+  0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c,
+  0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47,
+  0x45, 0x52, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c,
+  0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63,
+  0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73,
+  0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e,
+  0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e,
+  0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65,
+  0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55,
+  0x4c, 0x4c, 0x20, 0x43, 0x4f, 0x4c, 0x4c, 0x41, 0x54, 0x45, 0x20, 0x22,
+  0x43, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49,
+  0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e,
+  0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78,
+  0x20, 0x42, 0x49, 0x47, 0x49, 0x4e, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20,
+  0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x65, 0x78, 0x70, 0x72,
+  0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20,
+  0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20,
+  0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54,
+  0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x29, 0x0a, 0x53,
+  0x45, 0x52, 0x56, 0x45, 0x52, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x4f, 0x50, 0x54,
+  0x49, 0x4f, 0x4e, 0x53, 0x20, 0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f,
+  0x6e, 0x61, 0x6d, 0x65, 0x20, 0x27, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x5f, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x73, 0x27, 0x29, 0x3b, 0x0a,
+  0x0a, 0x2d, 0x2d, 0x20, 0x54, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x65,
+  0x69, 0x67, 0x6e, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x66, 0x6f,
+  0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x5f,
+  0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x6f, 0x62, 0x6a, 0x65,
+  0x63, 0x74, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e,
+  0x74, 0x73, 0x20, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x20, 0x28, 0x74,
+  0x68, 0x61, 0x74, 0x20, 0x69, 0x73, 0x0a, 0x2d, 0x2d, 0x20, 0x6f, 0x66,
+  0x20, 0x61, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x65, 0x72,
+  0x20, 0x74, 0x79, 0x70, 0x65, 0x29, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x43,
+  0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47,
+  0x4e, 0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x20, 0x62, 0x75, 0x69, 0x6c,
+  0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x63, 0x6f,
+  0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e, 0x74, 0x73, 0x20, 0x28, 0x0a,
+  0x20, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58,
+  0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a,
+  0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x49, 0x54, 0x45, 0x58,
+  0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a,
+  0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70,
+  0x6f, 0x63, 0x68, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x20,
+  0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f,
+  0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65,
+  0x61, 0x6d, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20,
+  0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61,
+  0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x54, 0x45,
+  0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20,
+  0x43, 0x4f, 0x4c, 0x4c, 0x41, 0x54, 0x45, 0x20, 0x22, 0x43, 0x22, 0x2c,
+  0x0a, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72,
+  0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x4e, 0x54, 0x45,
+  0x47, 0x45, 0x52, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c,
+  0x2c, 0x0a, 0x20, 0x20, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20, 0x42, 0x49,
+  0x47, 0x49, 0x4e, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c,
+  0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69,
+  0x6f, 0x6e, 0x20, 0x42, 0x4f, 0x4f, 0x4c, 0x45, 0x41, 0x4e, 0x20, 0x4e,
+  0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x63,
+  0x6f, 0x6e, 0x66, 0x69, 0x67, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e,
+  0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x74,
+  0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e,
+  0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x65,
+  0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x20, 0x4e, 0x4f, 0x54, 0x20,
+  0x4e, 0x55, 0x4c, 0x4c, 0x29, 0x0a, 0x53, 0x45, 0x52, 0x56, 0x45, 0x52,
+  0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x72,
+  0x76, 0x65, 0x72, 0x20, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x53, 0x20,
+  0x28, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20,
+  0x27, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x62, 0x75, 0x69,
+  0x6c, 0x64, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x74, 0x72, 0x61, 0x69, 0x6e,
+  0x74, 0x73, 0x27, 0x29, 0x3b, 0x0a
diff --git a/libbrep/build-odb.cxx b/libbrep/build-odb.cxx
new file mode 100644
index 0000000..1a75f07
--- /dev/null
+++ b/libbrep/build-odb.cxx
@@ -0,0 +1,4541 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#include <odb/pre.hxx>
+
+#include <libbrep/build-odb.hxx>
+
+#include <cassert>
+#include <cstring>  // std::memcpy
+
+#include <odb/schema-catalog-impl.hxx>
+
+#include <odb/pgsql/traits.hxx>
+#include <odb/pgsql/database.hxx>
+#include <odb/pgsql/transaction.hxx>
+#include <odb/pgsql/connection.hxx>
+#include <odb/pgsql/statement.hxx>
+#include <odb/pgsql/statement-cache.hxx>
+#include <odb/pgsql/simple-object-statements.hxx>
+#include <odb/pgsql/view-statements.hxx>
+#include <odb/pgsql/section-statements.hxx>
+#include <odb/pgsql/container-statements.hxx>
+#include <odb/pgsql/exceptions.hxx>
+#include <odb/pgsql/prepared-query.hxx>
+#include <odb/pgsql/simple-object-result.hxx>
+#include <odb/pgsql/view-result.hxx>
+
+namespace odb
+{
+  // operation_result
+  //
+
+  bool access::composite_value_traits< ::bbot::operation_result, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // operation
+    //
+    if (t[0UL])
+    {
+      i.operation_value.capacity (i.operation_size);
+      grew = true;
+    }
+
+    // status
+    //
+    if (t[1UL])
+    {
+      i.status_value.capacity (i.status_size);
+      grew = true;
+    }
+
+    // log
+    //
+    if (t[2UL])
+    {
+      i.log_value.capacity (i.log_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bbot::operation_result, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // operation
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.operation_value.data ();
+    b[n].capacity = i.operation_value.capacity ();
+    b[n].size = &i.operation_size;
+    b[n].is_null = &i.operation_null;
+    n++;
+
+    // status
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.status_value.data ();
+    b[n].capacity = i.status_value.capacity ();
+    b[n].size = &i.status_size;
+    b[n].is_null = &i.status_null;
+    n++;
+
+    // log
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.log_value.data ();
+    b[n].capacity = i.log_value.capacity ();
+    b[n].size = &i.log_size;
+    b[n].is_null = &i.log_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bbot::operation_result, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // operation
+    //
+    {
+      ::std::string const& v =
+        o.operation;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.operation_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.operation_value,
+        size,
+        is_null,
+        v);
+      i.operation_null = is_null;
+      i.operation_size = size;
+      grew = grew || (cap != i.operation_value.capacity ());
+    }
+
+    // status
+    //
+    {
+      ::bbot::result_status const& v =
+        o.status;
+
+      // From build.hxx:35:12
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.status_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.status_value,
+        size,
+        is_null,
+        vt);
+      i.status_null = is_null;
+      i.status_size = size;
+      grew = grew || (cap != i.status_value.capacity ());
+    }
+
+    // log
+    //
+    {
+      ::std::string const& v =
+        o.log;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.log_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.log_value,
+        size,
+        is_null,
+        v);
+      i.log_null = is_null;
+      i.log_size = size;
+      grew = grew || (cap != i.log_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bbot::operation_result, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // operation
+    //
+    {
+      ::std::string& v =
+        o.operation;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.operation_value,
+        i.operation_size,
+        i.operation_null);
+    }
+
+    // status
+    //
+    {
+      ::bbot::result_status& v =
+        o.status;
+
+      ::std::string vt;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.status_value,
+        i.status_size,
+        i.status_null);
+
+      // From build.hxx:35:12
+      v = bbot::to_result_status (vt);
+    }
+
+    // log
+    //
+    {
+      ::std::string& v =
+        o.log;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.log_value,
+        i.log_size,
+        i.log_null);
+    }
+  }
+
+  // build_id
+  //
+
+  bool access::composite_value_traits< ::brep::build_id, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // package
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.package_value, t + 0UL))
+      grew = true;
+
+    // configuration
+    //
+    if (t[6UL])
+    {
+      i.configuration_value.capacity (i.configuration_size);
+      grew = true;
+    }
+
+    // toolchain_name
+    //
+    if (t[7UL])
+    {
+      i.toolchain_name_value.capacity (i.toolchain_name_size);
+      grew = true;
+    }
+
+    // toolchain_version
+    //
+    if (composite_value_traits< ::brep::canonical_version, id_pgsql >::grow (
+          i.toolchain_version_value, t + 8UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::build_id, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // package
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.package_value, sk);
+    n += 6UL;
+
+    // configuration
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.configuration_value.data ();
+    b[n].capacity = i.configuration_value.capacity ();
+    b[n].size = &i.configuration_size;
+    b[n].is_null = &i.configuration_null;
+    n++;
+
+    // toolchain_name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.toolchain_name_value.data ();
+    b[n].capacity = i.toolchain_name_value.capacity ();
+    b[n].size = &i.toolchain_name_size;
+    b[n].is_null = &i.toolchain_name_null;
+    n++;
+
+    // toolchain_version
+    //
+    composite_value_traits< ::brep::canonical_version, id_pgsql >::bind (
+      b + n, i.toolchain_version_value, sk);
+    n += 4UL;
+  }
+
+  bool access::composite_value_traits< ::brep::build_id, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // package
+    //
+    {
+      ::brep::package_id const& v =
+        o.package;
+
+      if (composite_value_traits< ::brep::package_id, id_pgsql >::init (
+            i.package_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // configuration
+    //
+    {
+      ::std::string const& v =
+        o.configuration;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.configuration_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.configuration_value,
+        size,
+        is_null,
+        v);
+      i.configuration_null = is_null;
+      i.configuration_size = size;
+      grew = grew || (cap != i.configuration_value.capacity ());
+    }
+
+    // toolchain_name
+    //
+    {
+      ::std::string const& v =
+        o.toolchain_name;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.toolchain_name_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.toolchain_name_value,
+        size,
+        is_null,
+        v);
+      i.toolchain_name_null = is_null;
+      i.toolchain_name_size = size;
+      grew = grew || (cap != i.toolchain_name_value.capacity ());
+    }
+
+    // toolchain_version
+    //
+    {
+      ::brep::canonical_version const& v =
+        o.toolchain_version;
+
+      if (composite_value_traits< ::brep::canonical_version, id_pgsql >::init (
+            i.toolchain_version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::build_id, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // package
+    //
+    {
+      ::brep::package_id& v =
+        o.package;
+
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        v,
+        i.package_value,
+        db);
+    }
+
+    // configuration
+    //
+    {
+      ::std::string& v =
+        o.configuration;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.configuration_value,
+        i.configuration_size,
+        i.configuration_null);
+    }
+
+    // toolchain_name
+    //
+    {
+      ::std::string& v =
+        o.toolchain_name;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.toolchain_name_value,
+        i.toolchain_name_size,
+        i.toolchain_name_null);
+    }
+
+    // toolchain_version
+    //
+    {
+      ::brep::canonical_version& v =
+        o.toolchain_version;
+
+      composite_value_traits< ::brep::canonical_version, id_pgsql >::init (
+        v,
+        i.toolchain_version_value,
+        db);
+    }
+  }
+
+  // build
+  //
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::
+  persist_statement_name[] = "persist_brep_build";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::
+  find_statement_name[] = "find_brep_build";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::
+  update_statement_name[] = "update_brep_build";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::
+  erase_statement_name[] = "erase_brep_build";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::
+  query_statement_name[] = "query_brep_build";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_build";
+
+  const unsigned int access::object_traits_impl< ::brep::build, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::build, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::build, id_pgsql >::
+  update_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  struct access::object_traits_impl< ::brep::build, id_pgsql >::extra_statement_cache_type
+  {
+    pgsql::container_statements_impl< results_traits > results;
+
+    pgsql::section_statements< ::brep::build, results_section_traits > results_section;
+
+    extra_statement_cache_type (
+      pgsql::connection& c,
+      image_type& im,
+      id_image_type& idim,
+      pgsql::binding& id,
+      pgsql::binding& idv,
+      pgsql::native_binding& idn,
+      const unsigned int* idt)
+    : results (c, id, idn, idt),
+      results_section (c, im, idim, id, idv, idn, idt)
+    {
+    }
+  };
+
+  // results
+  //
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  select_name[] = "select_brep_build_results";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  insert_name[] = "insert_brep_build_results";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  delete_name[] = "delete_brep_build_results";
+
+  const unsigned int access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  select_statement[] =
+  "SELECT "
+  "\"build_results\".\"index\", "
+  "\"build_results\".\"operation\", "
+  "\"build_results\".\"status\", "
+  "\"build_results\".\"log\" "
+  "FROM \"build_results\" "
+  "WHERE \"build_results\".\"package_tenant\"=$1 AND \"build_results\".\"package_name\"=$2::CITEXT AND \"build_results\".\"package_version_epoch\"=$3 AND \"build_results\".\"package_version_canonical_upstream\"=$4 AND \"build_results\".\"package_version_canonical_release\"=$5 AND \"build_results\".\"package_version_revision\"=$6 AND \"build_results\".\"configuration\"=$7 AND \"build_results\".\"toolchain_name\"=$8 AND \"build_results\".\"toolchain_version_epoch\"=$9 AND \"build_results\".\"toolchain_version_canonical_upstream\"=$10 AND \"build_results\".\"toolchain_version_canonical_release\"=$11 AND \"build_results\".\"toolchain_version_revision\"=$12 ORDER BY \"build_results\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  insert_statement[] =
+  "INSERT INTO \"build_results\" "
+  "(\"package_tenant\", "
+  "\"package_name\", "
+  "\"package_version_epoch\", "
+  "\"package_version_canonical_upstream\", "
+  "\"package_version_canonical_release\", "
+  "\"package_version_revision\", "
+  "\"configuration\", "
+  "\"toolchain_name\", "
+  "\"toolchain_version_epoch\", "
+  "\"toolchain_version_canonical_upstream\", "
+  "\"toolchain_version_canonical_release\", "
+  "\"toolchain_version_revision\", "
+  "\"index\", "
+  "\"operation\", "
+  "\"status\", "
+  "\"log\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  delete_statement[] =
+  "DELETE FROM \"build_results\" "
+  "WHERE \"package_tenant\"=$1 AND \"package_name\"=$2::CITEXT AND \"package_version_epoch\"=$3 AND \"package_version_canonical_upstream\"=$4 AND \"package_version_canonical_release\"=$5 AND \"package_version_revision\"=$6 AND \"configuration\"=$7 AND \"toolchain_name\"=$8 AND \"toolchain_version_epoch\"=$9 AND \"toolchain_version_canonical_upstream\"=$10 AND \"toolchain_version_canonical_release\"=$11 AND \"toolchain_version_revision\"=$12";
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // results_section
+  //
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_section_traits::
+  load (extra_statement_cache_type& esc, object_type& obj)
+  {
+    // results
+    //
+    {
+      ::bbot::operation_results& v =
+        obj.results;
+
+      results_traits::load (
+        v,
+        esc.results);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::results_section_traits::
+  update (extra_statement_cache_type& esc, const object_type& obj)
+  {
+    // results
+    //
+    {
+      ::bbot::operation_results const& v =
+        obj.results;
+
+      results_traits::update (
+        v,
+        esc.results);
+    }
+  }
+
+  access::object_traits_impl< ::brep::build, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::build, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      composite_value_traits< ::brep::build_id, id_pgsql >::init (
+        id,
+        i.id_value,
+        db);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::build_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // package_version
+    //
+    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
+          i.package_version_value, t + 12UL))
+      grew = true;
+
+    // toolchain_version
+    //
+    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
+          i.toolchain_version_value, t + 14UL))
+      grew = true;
+
+    // state
+    //
+    if (t[16UL])
+    {
+      i.state_value.capacity (i.state_size);
+      grew = true;
+    }
+
+    // timestamp
+    //
+    t[17UL] = 0;
+
+    // force
+    //
+    if (t[18UL])
+    {
+      i.force_value.capacity (i.force_size);
+      grew = true;
+    }
+
+    // status
+    //
+    if (t[19UL])
+    {
+      i.status_value.capacity (i.status_size);
+      grew = true;
+    }
+
+    // completion_timestamp
+    //
+    t[20UL] = 0;
+
+    // agent_fingerprint
+    //
+    if (t[21UL])
+    {
+      i.agent_fingerprint_value.capacity (i.agent_fingerprint_size);
+      grew = true;
+    }
+
+    // agent_challenge
+    //
+    if (t[22UL])
+    {
+      i.agent_challenge_value.capacity (i.agent_challenge_size);
+      grew = true;
+    }
+
+    // machine
+    //
+    if (t[23UL])
+    {
+      i.machine_value.capacity (i.machine_size);
+      grew = true;
+    }
+
+    // machine_summary
+    //
+    if (t[24UL])
+    {
+      i.machine_summary_value.capacity (i.machine_summary_size);
+      grew = true;
+    }
+
+    // target
+    //
+    if (t[25UL])
+    {
+      i.target_value.capacity (i.target_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      composite_value_traits< ::brep::build_id, id_pgsql >::bind (
+        b + n, i.id_value, sk);
+      n += 12UL;
+    }
+
+    // package_version
+    //
+    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
+      b + n, i.package_version_value, sk);
+    n += 2UL;
+
+    // toolchain_version
+    //
+    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
+      b + n, i.toolchain_version_value, sk);
+    n += 2UL;
+
+    // state
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.state_value.data ();
+    b[n].capacity = i.state_value.capacity ();
+    b[n].size = &i.state_size;
+    b[n].is_null = &i.state_null;
+    n++;
+
+    // timestamp
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.timestamp_value;
+    b[n].is_null = &i.timestamp_null;
+    n++;
+
+    // force
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.force_value.data ();
+    b[n].capacity = i.force_value.capacity ();
+    b[n].size = &i.force_size;
+    b[n].is_null = &i.force_null;
+    n++;
+
+    // status
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.status_value.data ();
+    b[n].capacity = i.status_value.capacity ();
+    b[n].size = &i.status_size;
+    b[n].is_null = &i.status_null;
+    n++;
+
+    // completion_timestamp
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.completion_timestamp_value;
+    b[n].is_null = &i.completion_timestamp_null;
+    n++;
+
+    // agent_fingerprint
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.agent_fingerprint_value.data ();
+    b[n].capacity = i.agent_fingerprint_value.capacity ();
+    b[n].size = &i.agent_fingerprint_size;
+    b[n].is_null = &i.agent_fingerprint_null;
+    n++;
+
+    // agent_challenge
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.agent_challenge_value.data ();
+    b[n].capacity = i.agent_challenge_value.capacity ();
+    b[n].size = &i.agent_challenge_size;
+    b[n].is_null = &i.agent_challenge_null;
+    n++;
+
+    // machine
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.machine_value.data ();
+    b[n].capacity = i.machine_value.capacity ();
+    b[n].size = &i.machine_size;
+    b[n].is_null = &i.machine_null;
+    n++;
+
+    // machine_summary
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.machine_summary_value.data ();
+    b[n].capacity = i.machine_summary_value.capacity ();
+    b[n].size = &i.machine_summary_size;
+    b[n].is_null = &i.machine_summary_null;
+    n++;
+
+    // target
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.target_value.data ();
+    b[n].capacity = i.target_value.capacity ();
+    b[n].size = &i.target_size;
+    b[n].is_null = &i.target_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    composite_value_traits< ::brep::build_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::brep::build_id const& v =
+        o.id;
+
+      if (composite_value_traits< ::brep::build_id, id_pgsql >::init (
+            i.id_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // package_version
+    //
+    {
+      ::brep::upstream_version const& v =
+        o.package_version;
+
+      if (composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+            i.package_version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // toolchain_version
+    //
+    {
+      ::brep::upstream_version const& v =
+        o.toolchain_version;
+
+      if (composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+            i.toolchain_version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // state
+    //
+    {
+      ::brep::build_state const& v =
+        o.state;
+
+      // From build.hxx:122:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.state_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.state_value,
+        size,
+        is_null,
+        vt);
+      i.state_null = is_null;
+      i.state_size = size;
+      grew = grew || (cap != i.state_value.capacity ());
+    }
+
+    // timestamp
+    //
+    {
+      ::brep::build::timestamp_type const& v =
+        o.timestamp;
+
+      // From common.hxx:119:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_image (
+        i.timestamp_value, is_null, vt);
+      i.timestamp_null = is_null;
+    }
+
+    // force
+    //
+    {
+      ::brep::force_state const& v =
+        o.force;
+
+      // From build.hxx:144:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.force_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.force_value,
+        size,
+        is_null,
+        vt);
+      i.force_null = is_null;
+      i.force_size = size;
+      grew = grew || (cap != i.force_value.capacity ());
+    }
+
+    // status
+    //
+    {
+      ::butl::optional< ::bbot::result_status > const& v =
+        o.status;
+
+      // From build.hxx:154:14
+      ::brep::optional_string const& vt =
+        (v) ? bbot::to_string ( * (v)) : brep::optional_string ();
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.status_value.capacity ());
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_image (
+        i.status_value,
+        size,
+        is_null,
+        vt);
+      i.status_null = is_null;
+      i.status_size = size;
+      grew = grew || (cap != i.status_value.capacity ());
+    }
+
+    // completion_timestamp
+    //
+    {
+      ::brep::build::timestamp_type const& v =
+        o.completion_timestamp;
+
+      // From common.hxx:119:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_image (
+        i.completion_timestamp_value, is_null, vt);
+      i.completion_timestamp_null = is_null;
+    }
+
+    // agent_fingerprint
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.agent_fingerprint;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.agent_fingerprint_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.agent_fingerprint_value,
+        size,
+        is_null,
+        v);
+      i.agent_fingerprint_null = is_null;
+      i.agent_fingerprint_size = size;
+      grew = grew || (cap != i.agent_fingerprint_value.capacity ());
+    }
+
+    // agent_challenge
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.agent_challenge;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.agent_challenge_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.agent_challenge_value,
+        size,
+        is_null,
+        v);
+      i.agent_challenge_null = is_null;
+      i.agent_challenge_size = size;
+      grew = grew || (cap != i.agent_challenge_value.capacity ());
+    }
+
+    // machine
+    //
+    {
+      ::std::string const& v =
+        o.machine;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.machine_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.machine_value,
+        size,
+        is_null,
+        v);
+      i.machine_null = is_null;
+      i.machine_size = size;
+      grew = grew || (cap != i.machine_value.capacity ());
+    }
+
+    // machine_summary
+    //
+    {
+      ::std::string const& v =
+        o.machine_summary;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.machine_summary_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.machine_summary_value,
+        size,
+        is_null,
+        v);
+      i.machine_summary_null = is_null;
+      i.machine_summary_size = size;
+      grew = grew || (cap != i.machine_summary_value.capacity ());
+    }
+
+    // target
+    //
+    {
+      ::butl::target_triplet const& v =
+        o.target;
+
+      // From build.hxx:162:14
+      ::std::string const& vt =
+        (v).string ();
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.target_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.target_value,
+        size,
+        is_null,
+        vt);
+      i.target_null = is_null;
+      i.target_size = size;
+      grew = grew || (cap != i.target_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::build_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::build_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // package_version
+    //
+    {
+      // From build.hxx:247:7
+      ::brep::upstream_version v;
+
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+        v,
+        i.package_version_value,
+        db);
+
+      // From build.hxx:247:7
+      o.package_version.init (o.id.package.version, (v));
+    }
+
+    // toolchain_version
+    //
+    {
+      // From build.hxx:251:7
+      ::brep::upstream_version v;
+
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+        v,
+        i.toolchain_version_value,
+        db);
+
+      // From build.hxx:251:7
+      o.toolchain_version.init (o.id.toolchain_version, (v));
+    }
+
+    // state
+    //
+    {
+      ::brep::build_state& v =
+        o.state;
+
+      ::std::string vt;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.state_value,
+        i.state_size,
+        i.state_null);
+
+      // From build.hxx:122:14
+      v = brep::to_build_state (vt);
+    }
+
+    // timestamp
+    //
+    {
+      ::brep::build::timestamp_type& v =
+        o.timestamp;
+
+      ::uint64_t vt;
+
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_value (
+        vt,
+        i.timestamp_value,
+        i.timestamp_null);
+
+      // From common.hxx:119:14
+      v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+
+    // force
+    //
+    {
+      ::brep::force_state& v =
+        o.force;
+
+      ::std::string vt;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.force_value,
+        i.force_size,
+        i.force_null);
+
+      // From build.hxx:144:14
+      v = brep::to_force_state (vt);
+    }
+
+    // status
+    //
+    {
+      ::butl::optional< ::bbot::result_status >& v =
+        o.status;
+
+      ::brep::optional_string vt;
+
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.status_value,
+        i.status_size,
+        i.status_null);
+
+      // From build.hxx:154:14
+      v = (vt) ? bbot::to_result_status ( * (vt)) : brep::optional_result_status ();
+    }
+
+    // completion_timestamp
+    //
+    {
+      ::brep::build::timestamp_type& v =
+        o.completion_timestamp;
+
+      ::uint64_t vt;
+
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_value (
+        vt,
+        i.completion_timestamp_value,
+        i.completion_timestamp_null);
+
+      // From common.hxx:119:14
+      v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+
+    // agent_fingerprint
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.agent_fingerprint;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.agent_fingerprint_value,
+        i.agent_fingerprint_size,
+        i.agent_fingerprint_null);
+    }
+
+    // agent_challenge
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.agent_challenge;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.agent_challenge_value,
+        i.agent_challenge_size,
+        i.agent_challenge_null);
+    }
+
+    // machine
+    //
+    {
+      ::std::string& v =
+        o.machine;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.machine_value,
+        i.machine_size,
+        i.machine_null);
+    }
+
+    // machine_summary
+    //
+    {
+      ::std::string& v =
+        o.machine_summary;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.machine_summary_value,
+        i.machine_summary_size,
+        i.machine_summary_null);
+    }
+
+    // target
+    //
+    {
+      ::butl::target_triplet& v =
+        o.target;
+
+      ::std::string vt;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.target_value,
+        i.target_size,
+        i.target_null);
+
+      // From build.hxx:162:14
+      v = butl::target_triplet (vt);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    {
+      if (composite_value_traits< ::brep::build_id, id_pgsql >::init (
+            i.id_value,
+            id,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"build\" "
+  "(\"package_tenant\", "
+  "\"package_name\", "
+  "\"package_version_epoch\", "
+  "\"package_version_canonical_upstream\", "
+  "\"package_version_canonical_release\", "
+  "\"package_version_revision\", "
+  "\"configuration\", "
+  "\"toolchain_name\", "
+  "\"toolchain_version_epoch\", "
+  "\"toolchain_version_canonical_upstream\", "
+  "\"toolchain_version_canonical_release\", "
+  "\"toolchain_version_revision\", "
+  "\"package_version_upstream\", "
+  "\"package_version_release\", "
+  "\"toolchain_version_upstream\", "
+  "\"toolchain_version_release\", "
+  "\"state\", "
+  "\"timestamp\", "
+  "\"force\", "
+  "\"status\", "
+  "\"completion_timestamp\", "
+  "\"agent_fingerprint\", "
+  "\"agent_challenge\", "
+  "\"machine\", "
+  "\"machine_summary\", "
+  "\"target\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26)";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"build\".\"package_tenant\", "
+  "\"build\".\"package_name\"::TEXT, "
+  "\"build\".\"package_version_epoch\", "
+  "\"build\".\"package_version_canonical_upstream\", "
+  "\"build\".\"package_version_canonical_release\", "
+  "\"build\".\"package_version_revision\", "
+  "\"build\".\"configuration\", "
+  "\"build\".\"toolchain_name\", "
+  "\"build\".\"toolchain_version_epoch\", "
+  "\"build\".\"toolchain_version_canonical_upstream\", "
+  "\"build\".\"toolchain_version_canonical_release\", "
+  "\"build\".\"toolchain_version_revision\", "
+  "\"build\".\"package_version_upstream\", "
+  "\"build\".\"package_version_release\", "
+  "\"build\".\"toolchain_version_upstream\", "
+  "\"build\".\"toolchain_version_release\", "
+  "\"build\".\"state\", "
+  "\"build\".\"timestamp\", "
+  "\"build\".\"force\", "
+  "\"build\".\"status\", "
+  "\"build\".\"completion_timestamp\", "
+  "\"build\".\"agent_fingerprint\", "
+  "\"build\".\"agent_challenge\", "
+  "\"build\".\"machine\", "
+  "\"build\".\"machine_summary\", "
+  "\"build\".\"target\" "
+  "FROM \"build\" "
+  "WHERE \"build\".\"package_tenant\"=$1 AND \"build\".\"package_name\"=$2::CITEXT AND \"build\".\"package_version_epoch\"=$3 AND \"build\".\"package_version_canonical_upstream\"=$4 AND \"build\".\"package_version_canonical_release\"=$5 AND \"build\".\"package_version_revision\"=$6 AND \"build\".\"configuration\"=$7 AND \"build\".\"toolchain_name\"=$8 AND \"build\".\"toolchain_version_epoch\"=$9 AND \"build\".\"toolchain_version_canonical_upstream\"=$10 AND \"build\".\"toolchain_version_canonical_release\"=$11 AND \"build\".\"toolchain_version_revision\"=$12";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::update_statement[] =
+  "UPDATE \"build\" "
+  "SET "
+  "\"package_version_upstream\"=$1, "
+  "\"package_version_release\"=$2, "
+  "\"toolchain_version_upstream\"=$3, "
+  "\"toolchain_version_release\"=$4, "
+  "\"state\"=$5, "
+  "\"timestamp\"=$6, "
+  "\"force\"=$7, "
+  "\"status\"=$8, "
+  "\"completion_timestamp\"=$9, "
+  "\"agent_fingerprint\"=$10, "
+  "\"agent_challenge\"=$11, "
+  "\"machine\"=$12, "
+  "\"machine_summary\"=$13, "
+  "\"target\"=$14 "
+  "WHERE \"package_tenant\"=$15 AND \"package_name\"=$16::CITEXT AND \"package_version_epoch\"=$17 AND \"package_version_canonical_upstream\"=$18 AND \"package_version_canonical_release\"=$19 AND \"package_version_revision\"=$20 AND \"configuration\"=$21 AND \"toolchain_name\"=$22 AND \"toolchain_version_epoch\"=$23 AND \"toolchain_version_canonical_upstream\"=$24 AND \"toolchain_version_canonical_release\"=$25 AND \"toolchain_version_revision\"=$26";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"build\" "
+  "WHERE \"package_tenant\"=$1 AND \"package_name\"=$2::CITEXT AND \"package_version_epoch\"=$3 AND \"package_version_canonical_upstream\"=$4 AND \"package_version_canonical_release\"=$5 AND \"package_version_revision\"=$6 AND \"configuration\"=$7 AND \"toolchain_name\"=$8 AND \"toolchain_version_epoch\"=$9 AND \"toolchain_version_canonical_upstream\"=$10 AND \"toolchain_version_canonical_release\"=$11 AND \"toolchain_version_revision\"=$12";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::query_statement[] =
+  "SELECT "
+  "\"build\".\"package_tenant\", "
+  "\"build\".\"package_name\"::TEXT, "
+  "\"build\".\"package_version_epoch\", "
+  "\"build\".\"package_version_canonical_upstream\", "
+  "\"build\".\"package_version_canonical_release\", "
+  "\"build\".\"package_version_revision\", "
+  "\"build\".\"configuration\", "
+  "\"build\".\"toolchain_name\", "
+  "\"build\".\"toolchain_version_epoch\", "
+  "\"build\".\"toolchain_version_canonical_upstream\", "
+  "\"build\".\"toolchain_version_canonical_release\", "
+  "\"build\".\"toolchain_version_revision\", "
+  "\"build\".\"package_version_upstream\", "
+  "\"build\".\"package_version_release\", "
+  "\"build\".\"toolchain_version_upstream\", "
+  "\"build\".\"toolchain_version_release\", "
+  "\"build\".\"state\", "
+  "\"build\".\"timestamp\", "
+  "\"build\".\"force\", "
+  "\"build\".\"status\", "
+  "\"build\".\"completion_timestamp\", "
+  "\"build\".\"agent_fingerprint\", "
+  "\"build\".\"agent_challenge\", "
+  "\"build\".\"machine\", "
+  "\"build\".\"machine_summary\", "
+  "\"build\".\"target\" "
+  "FROM \"build\"";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"build\"";
+
+  const char access::object_traits_impl< ::brep::build, id_pgsql >::table_name[] =
+  "\"build\"";
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // results
+    //
+    {
+      ::bbot::operation_results const& v =
+        obj.results;
+
+      results_traits::persist (
+        v,
+        esc.results);
+    }
+
+    obj.results_section.reset (true, false);
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+    using pgsql::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    pgsql::transaction& tr (pgsql::transaction::current ());
+    pgsql::connection& conn (tr.connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    if (obj.results_section.loaded ())
+    {
+      results_section_traits::update (esc, obj);
+    }
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // results
+    //
+    {
+      results_traits::erase (
+        esc.results);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::build, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::build, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::
+  load (connection& conn, object_type& obj, section& s)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& c (static_cast<pgsql::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    bool r (false);
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    if (!r && &s == &obj.results_section)
+    {
+      results_section_traits::load (esc, obj);
+      r = true;
+    }
+
+    sts.load_delayed (0);
+    l.unlock ();
+    return r;
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::
+  update (connection& conn, const object_type& obj, const section& s)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& c (static_cast<pgsql::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (&s == &obj.results_section)results_section_traits::update (esc, obj);
+    else
+      return false;
+
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    if (reload)
+    {
+      if (obj.results_section.loaded ())
+      {
+        results_section_traits::load (esc, obj);
+        obj.results_section.reset (true, false);
+      }
+    }
+    else
+      obj.results_section.reset ();
+  }
+
+  result< access::object_traits_impl< ::brep::build, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::build, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        false,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::build, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::build, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::build, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // toolchain
+  //
+
+  const char access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  query_statement_name[] = "query_brep_toolchain";
+
+  bool access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // epoch
+    //
+    t[1UL] = 0;
+
+    // canonical_upstream
+    //
+    if (t[2UL])
+    {
+      i.canonical_upstream_value.capacity (i.canonical_upstream_size);
+      grew = true;
+    }
+
+    // canonical_release
+    //
+    if (t[3UL])
+    {
+      i.canonical_release_value.capacity (i.canonical_release_size);
+      grew = true;
+    }
+
+    // revision
+    //
+    t[4UL] = 0;
+
+    // version
+    //
+    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
+          i.version_value, t + 5UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.name_value.data ();
+    b[n].capacity = i.name_value.capacity ();
+    b[n].size = &i.name_size;
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // epoch
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.epoch_value;
+    b[n].is_null = &i.epoch_null;
+    n++;
+
+    // canonical_upstream
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.canonical_upstream_value.data ();
+    b[n].capacity = i.canonical_upstream_value.capacity ();
+    b[n].size = &i.canonical_upstream_size;
+    b[n].is_null = &i.canonical_upstream_null;
+    n++;
+
+    // canonical_release
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.canonical_release_value.data ();
+    b[n].capacity = i.canonical_release_value.capacity ();
+    b[n].size = &i.canonical_release_size;
+    b[n].is_null = &i.canonical_release_null;
+    n++;
+
+    // revision
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.revision_value;
+    b[n].is_null = &i.revision_null;
+    n++;
+
+    // version
+    //
+    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
+      b + n, i.version_value, sk);
+    n += 2UL;
+  }
+
+  void access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // epoch
+    //
+    {
+      // From build.hxx:309:23
+      ::uint16_t& v =
+        o.version_.epoch;
+
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_value (
+        v,
+        i.epoch_value,
+        i.epoch_null);
+    }
+
+    // canonical_upstream
+    //
+    {
+      // From build.hxx:313:23
+      ::std::string& v =
+        o.version_.canonical_upstream;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.canonical_upstream_value,
+        i.canonical_upstream_size,
+        i.canonical_upstream_null);
+    }
+
+    // canonical_release
+    //
+    {
+      // From build.hxx:317:23
+      ::std::string& v =
+        o.version_.canonical_release;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.canonical_release_value,
+        i.canonical_release_size,
+        i.canonical_release_null);
+    }
+
+    // revision
+    //
+    {
+      // From build.hxx:321:23
+      ::uint16_t& v =
+        o.version_.revision;
+
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_value (
+        v,
+        i.revision_value,
+        i.revision_null);
+    }
+
+    // version
+    //
+    {
+      // From build.hxx:306:7
+      ::brep::upstream_version v;
+
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+        v,
+        i.version_value,
+        db);
+
+      // From build.hxx:306:7
+      o.version.init (o.version_, (v));
+    }
+  }
+
+  access::view_traits_impl< ::brep::toolchain, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT DISTINCT "
+      "\"build\".\"toolchain_name\", "
+      "\"build\".\"toolchain_version_epoch\", "
+      "\"build\".\"toolchain_version_canonical_upstream\", "
+      "\"build\".\"toolchain_version_canonical_release\", "
+      "\"build\".\"toolchain_version_revision\", "
+      "\"build\".\"toolchain_version_upstream\", "
+      "\"build\".\"toolchain_version_release\" ");
+
+    r += "FROM \"build\"";
+
+    r += " INNER JOIN \"build_package\" ON";
+    // From build.hxx:291:5
+    r += brep::operator == (query_columns::build::id.package, query_columns::build_package::id) && query_columns::build_package::buildable;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::toolchain, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::toolchain, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // package_build
+  //
+
+  const char access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  query_statement_name[] = "query_brep_package_build";
+
+  bool access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // build
+    //
+    if (object_traits_impl< ::brep::build, id_pgsql >::grow (
+          i.build_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // build
+    //
+    object_traits_impl< ::brep::build, id_pgsql >::bind (
+      b + n, i.build_value, sk);
+    n += 26UL;
+  }
+
+  void access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // build pre
+    //
+    typedef ::brep::build build_object_type;
+    typedef object_traits_impl<build_object_type, id_pgsql> build_object_traits;
+    typedef build_object_traits::pointer_type build_pointer_type;
+    typedef build_object_traits::pointer_traits build_pointer_traits;
+    typedef build_object_traits::pointer_cache_traits build_cache_traits;
+
+    build_object_traits::id_type build_id;
+    build_pointer_type build_p;
+    build_pointer_traits::guard build_pg;
+    build_cache_traits::insert_guard build_ig;
+    build_object_type* build_o (0);
+
+    {
+      if (!composite_value_traits< build_object_traits::id_type, id_pgsql >::get_null (
+            i.build_value.id_value))
+      {
+        build_id = build_object_traits::id (i.build_value);
+        build_p = build_cache_traits::find (*db, build_id);
+
+        if (build_pointer_traits::null_ptr (build_p))
+        {
+          build_p = object_factory<build_object_type, build_pointer_type>::create ();
+          build_pg.reset (build_p);
+          build_ig.reset (build_cache_traits::insert (*db, build_id, build_p));
+          build_o = build_pointer_traits::get_ptr (build_p);
+        }
+      }
+    }
+
+    // build
+    //
+    {
+      if (build_o != 0)
+      {
+        build_object_traits::callback (*db, *build_o, callback_event::pre_load);
+        build_object_traits::init (*build_o, i.build_value, db);
+        build_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<build_object_type> ());
+        build_object_traits::load_ (sts, *build_o, false);
+      }
+    }
+
+    // build post
+    //
+    {
+      if (build_o != 0)
+      {
+        build_object_traits::callback (*db, *build_o, callback_event::post_load);
+        build_cache_traits::load (build_ig.position ());
+        build_ig.release ();
+        build_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.build = ::std::shared_ptr< ::brep::build > (
+        std::move (build_p));
+    }
+  }
+
+  access::view_traits_impl< ::brep::package_build, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"build\".\"package_tenant\", "
+      "\"build\".\"package_name\"::TEXT, "
+      "\"build\".\"package_version_epoch\", "
+      "\"build\".\"package_version_canonical_upstream\", "
+      "\"build\".\"package_version_canonical_release\", "
+      "\"build\".\"package_version_revision\", "
+      "\"build\".\"configuration\", "
+      "\"build\".\"toolchain_name\", "
+      "\"build\".\"toolchain_version_epoch\", "
+      "\"build\".\"toolchain_version_canonical_upstream\", "
+      "\"build\".\"toolchain_version_canonical_release\", "
+      "\"build\".\"toolchain_version_revision\", "
+      "\"build\".\"package_version_upstream\", "
+      "\"build\".\"package_version_release\", "
+      "\"build\".\"toolchain_version_upstream\", "
+      "\"build\".\"toolchain_version_release\", "
+      "\"build\".\"state\", "
+      "\"build\".\"timestamp\", "
+      "\"build\".\"force\", "
+      "\"build\".\"status\", "
+      "\"build\".\"completion_timestamp\", "
+      "\"build\".\"agent_fingerprint\", "
+      "\"build\".\"agent_challenge\", "
+      "\"build\".\"machine\", "
+      "\"build\".\"machine_summary\", "
+      "\"build\".\"target\" ");
+
+    r += "FROM \"build\"";
+
+    r += " INNER JOIN \"build_package\" ON";
+    // From build.hxx:335:5
+    r += brep::operator == (query_columns::build::id.package, query_columns::build_package::id) && query_columns::build_package::buildable;
+
+    r += " LEFT JOIN \"build_tenant\" ON";
+    // From build.hxx:338:5
+    r += query_columns::build_package::id.tenant == query_columns::build_tenant::id;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::package_build, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::package_build, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // package_build_count
+  //
+
+  const char access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  query_statement_name[] = "query_brep_package_build_count";
+
+  bool access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = 0;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      pgsql::value_traits<
+          ::std::size_t,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::package_build_count, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "count(\"build\".\"package_name\") ");
+
+    r += "FROM \"build\"";
+
+    r += " INNER JOIN \"build_package\" ON";
+    // From build.hxx:346:5
+    r += brep::operator == (query_columns::build::id.package, query_columns::build_package::id) && query_columns::build_package::buildable;
+
+    r += " LEFT JOIN \"build_tenant\" ON";
+    // From build.hxx:349:5
+    r += query_columns::build_package::id.tenant == query_columns::build_tenant::id;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::package_build_count, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::package_build_count, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // build_delay
+  //
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  persist_statement_name[] = "persist_brep_build_delay";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  find_statement_name[] = "find_brep_build_delay";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  update_statement_name[] = "update_brep_build_delay";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  erase_statement_name[] = "erase_brep_build_delay";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  query_statement_name[] = "query_brep_build_delay";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_build_delay";
+
+  const unsigned int access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::int8_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  update_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  struct access::object_traits_impl< ::brep::build_delay, id_pgsql >::extra_statement_cache_type
+  {
+    extra_statement_cache_type (
+      pgsql::connection&,
+      image_type&,
+      id_image_type&,
+      pgsql::binding&,
+      pgsql::binding&,
+      pgsql::native_binding&,
+      const unsigned int*)
+    {
+    }
+  };
+
+  access::object_traits_impl< ::brep::build_delay, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      composite_value_traits< ::brep::build_id, id_pgsql >::init (
+        id,
+        i.id_value,
+        db);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::build_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // package_version
+    //
+    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
+          i.package_version_value, t + 12UL))
+      grew = true;
+
+    // toolchain_version
+    //
+    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
+          i.toolchain_version_value, t + 14UL))
+      grew = true;
+
+    // report_timestamp
+    //
+    t[16UL] = 0;
+
+    // package_timestamp
+    //
+    t[17UL] = 0;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      composite_value_traits< ::brep::build_id, id_pgsql >::bind (
+        b + n, i.id_value, sk);
+      n += 12UL;
+    }
+
+    // package_version
+    //
+    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
+      b + n, i.package_version_value, sk);
+    n += 2UL;
+
+    // toolchain_version
+    //
+    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
+      b + n, i.toolchain_version_value, sk);
+    n += 2UL;
+
+    // report_timestamp
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.report_timestamp_value;
+    b[n].is_null = &i.report_timestamp_null;
+    n++;
+
+    // package_timestamp
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.package_timestamp_value;
+    b[n].is_null = &i.package_timestamp_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    composite_value_traits< ::brep::build_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+  }
+
+  bool access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::brep::build_id const& v =
+        o.id;
+
+      if (composite_value_traits< ::brep::build_id, id_pgsql >::init (
+            i.id_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // package_version
+    //
+    {
+      ::brep::upstream_version const& v =
+        o.package_version;
+
+      if (composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+            i.package_version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // toolchain_version
+    //
+    {
+      ::brep::upstream_version const& v =
+        o.toolchain_version;
+
+      if (composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+            i.toolchain_version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // report_timestamp
+    //
+    {
+      ::butl::timestamp const& v =
+        o.report_timestamp;
+
+      // From common.hxx:119:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_image (
+        i.report_timestamp_value, is_null, vt);
+      i.report_timestamp_null = is_null;
+    }
+
+    // package_timestamp
+    //
+    {
+      ::butl::timestamp const& v =
+        o.package_timestamp;
+
+      // From common.hxx:119:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_image (
+        i.package_timestamp_value, is_null, vt);
+      i.package_timestamp_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::build_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::build_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // package_version
+    //
+    {
+      // From build.hxx:407:7
+      ::brep::upstream_version v;
+
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+        v,
+        i.package_version_value,
+        db);
+
+      // From build.hxx:407:7
+      o.package_version.init (o.id.package.version, (v));
+    }
+
+    // toolchain_version
+    //
+    {
+      // From build.hxx:411:7
+      ::brep::upstream_version v;
+
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+        v,
+        i.toolchain_version_value,
+        db);
+
+      // From build.hxx:411:7
+      o.toolchain_version.init (o.id.toolchain_version, (v));
+    }
+
+    // report_timestamp
+    //
+    {
+      ::butl::timestamp& v =
+        o.report_timestamp;
+
+      ::uint64_t vt;
+
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_value (
+        vt,
+        i.report_timestamp_value,
+        i.report_timestamp_null);
+
+      // From common.hxx:119:14
+      v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+
+    // package_timestamp
+    //
+    {
+      ::butl::timestamp& v =
+        o.package_timestamp;
+
+      ::uint64_t vt;
+
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_value (
+        vt,
+        i.package_timestamp_value,
+        i.package_timestamp_null);
+
+      // From common.hxx:119:14
+      v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    {
+      if (composite_value_traits< ::brep::build_id, id_pgsql >::init (
+            i.id_value,
+            id,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"build_delay\" "
+  "(\"package_tenant\", "
+  "\"package_name\", "
+  "\"package_version_epoch\", "
+  "\"package_version_canonical_upstream\", "
+  "\"package_version_canonical_release\", "
+  "\"package_version_revision\", "
+  "\"configuration\", "
+  "\"toolchain_name\", "
+  "\"toolchain_version_epoch\", "
+  "\"toolchain_version_canonical_upstream\", "
+  "\"toolchain_version_canonical_release\", "
+  "\"toolchain_version_revision\", "
+  "\"package_version_upstream\", "
+  "\"package_version_release\", "
+  "\"toolchain_version_upstream\", "
+  "\"toolchain_version_release\", "
+  "\"report_timestamp\", "
+  "\"package_timestamp\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"build_delay\".\"package_tenant\", "
+  "\"build_delay\".\"package_name\"::TEXT, "
+  "\"build_delay\".\"package_version_epoch\", "
+  "\"build_delay\".\"package_version_canonical_upstream\", "
+  "\"build_delay\".\"package_version_canonical_release\", "
+  "\"build_delay\".\"package_version_revision\", "
+  "\"build_delay\".\"configuration\", "
+  "\"build_delay\".\"toolchain_name\", "
+  "\"build_delay\".\"toolchain_version_epoch\", "
+  "\"build_delay\".\"toolchain_version_canonical_upstream\", "
+  "\"build_delay\".\"toolchain_version_canonical_release\", "
+  "\"build_delay\".\"toolchain_version_revision\", "
+  "\"build_delay\".\"package_version_upstream\", "
+  "\"build_delay\".\"package_version_release\", "
+  "\"build_delay\".\"toolchain_version_upstream\", "
+  "\"build_delay\".\"toolchain_version_release\", "
+  "\"build_delay\".\"report_timestamp\", "
+  "\"build_delay\".\"package_timestamp\" "
+  "FROM \"build_delay\" "
+  "WHERE \"build_delay\".\"package_tenant\"=$1 AND \"build_delay\".\"package_name\"=$2::CITEXT AND \"build_delay\".\"package_version_epoch\"=$3 AND \"build_delay\".\"package_version_canonical_upstream\"=$4 AND \"build_delay\".\"package_version_canonical_release\"=$5 AND \"build_delay\".\"package_version_revision\"=$6 AND \"build_delay\".\"configuration\"=$7 AND \"build_delay\".\"toolchain_name\"=$8 AND \"build_delay\".\"toolchain_version_epoch\"=$9 AND \"build_delay\".\"toolchain_version_canonical_upstream\"=$10 AND \"build_delay\".\"toolchain_version_canonical_release\"=$11 AND \"build_delay\".\"toolchain_version_revision\"=$12";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::update_statement[] =
+  "UPDATE \"build_delay\" "
+  "SET "
+  "\"package_version_upstream\"=$1, "
+  "\"package_version_release\"=$2, "
+  "\"toolchain_version_upstream\"=$3, "
+  "\"toolchain_version_release\"=$4, "
+  "\"report_timestamp\"=$5, "
+  "\"package_timestamp\"=$6 "
+  "WHERE \"package_tenant\"=$7 AND \"package_name\"=$8::CITEXT AND \"package_version_epoch\"=$9 AND \"package_version_canonical_upstream\"=$10 AND \"package_version_canonical_release\"=$11 AND \"package_version_revision\"=$12 AND \"configuration\"=$13 AND \"toolchain_name\"=$14 AND \"toolchain_version_epoch\"=$15 AND \"toolchain_version_canonical_upstream\"=$16 AND \"toolchain_version_canonical_release\"=$17 AND \"toolchain_version_revision\"=$18";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"build_delay\" "
+  "WHERE \"package_tenant\"=$1 AND \"package_name\"=$2::CITEXT AND \"package_version_epoch\"=$3 AND \"package_version_canonical_upstream\"=$4 AND \"package_version_canonical_release\"=$5 AND \"package_version_revision\"=$6 AND \"configuration\"=$7 AND \"toolchain_name\"=$8 AND \"toolchain_version_epoch\"=$9 AND \"toolchain_version_canonical_upstream\"=$10 AND \"toolchain_version_canonical_release\"=$11 AND \"toolchain_version_revision\"=$12";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::query_statement[] =
+  "SELECT "
+  "\"build_delay\".\"package_tenant\", "
+  "\"build_delay\".\"package_name\"::TEXT, "
+  "\"build_delay\".\"package_version_epoch\", "
+  "\"build_delay\".\"package_version_canonical_upstream\", "
+  "\"build_delay\".\"package_version_canonical_release\", "
+  "\"build_delay\".\"package_version_revision\", "
+  "\"build_delay\".\"configuration\", "
+  "\"build_delay\".\"toolchain_name\", "
+  "\"build_delay\".\"toolchain_version_epoch\", "
+  "\"build_delay\".\"toolchain_version_canonical_upstream\", "
+  "\"build_delay\".\"toolchain_version_canonical_release\", "
+  "\"build_delay\".\"toolchain_version_revision\", "
+  "\"build_delay\".\"package_version_upstream\", "
+  "\"build_delay\".\"package_version_release\", "
+  "\"build_delay\".\"toolchain_version_upstream\", "
+  "\"build_delay\".\"toolchain_version_release\", "
+  "\"build_delay\".\"report_timestamp\", "
+  "\"build_delay\".\"package_timestamp\" "
+  "FROM \"build_delay\"";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"build_delay\"";
+
+  const char access::object_traits_impl< ::brep::build_delay, id_pgsql >::table_name[] =
+  "\"build_delay\"";
+
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+    using pgsql::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    pgsql::transaction& tr (pgsql::transaction::current ());
+    pgsql::connection& conn (tr.connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::build_delay, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  result< access::object_traits_impl< ::brep::build_delay, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        false,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+}
+
+namespace odb
+{
+  static bool
+  create_schema (database& db, unsigned short pass, bool drop)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (pass);
+    ODB_POTENTIALLY_UNUSED (drop);
+
+    if (drop)
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("DROP TABLE IF EXISTS \"build_delay\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"build_results\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"build\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"schema_version\"");
+          return false;
+        }
+      }
+    }
+    else
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          db.execute ("CREATE TABLE \"build\" (\n"
+                      "  \"package_tenant\" TEXT NOT NULL,\n"
+                      "  \"package_name\" CITEXT NOT NULL,\n"
+                      "  \"package_version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"package_version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"package_version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"package_version_revision\" INTEGER NOT NULL,\n"
+                      "  \"configuration\" TEXT NOT NULL,\n"
+                      "  \"toolchain_name\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"toolchain_version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"toolchain_version_revision\" INTEGER NOT NULL,\n"
+                      "  \"package_version_upstream\" TEXT NOT NULL,\n"
+                      "  \"package_version_release\" TEXT NULL,\n"
+                      "  \"toolchain_version_upstream\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_release\" TEXT NULL,\n"
+                      "  \"state\" TEXT NOT NULL,\n"
+                      "  \"timestamp\" BIGINT NOT NULL,\n"
+                      "  \"force\" TEXT NOT NULL,\n"
+                      "  \"status\" TEXT NULL,\n"
+                      "  \"completion_timestamp\" BIGINT NOT NULL DEFAULT 0,\n"
+                      "  \"agent_fingerprint\" TEXT NULL,\n"
+                      "  \"agent_challenge\" TEXT NULL,\n"
+                      "  \"machine\" TEXT NOT NULL,\n"
+                      "  \"machine_summary\" TEXT NOT NULL,\n"
+                      "  \"target\" TEXT NOT NULL,\n"
+                      "  PRIMARY KEY (\"package_tenant\",\n"
+                      "               \"package_name\",\n"
+                      "               \"package_version_epoch\",\n"
+                      "               \"package_version_canonical_upstream\",\n"
+                      "               \"package_version_canonical_release\",\n"
+                      "               \"package_version_revision\",\n"
+                      "               \"configuration\",\n"
+                      "               \"toolchain_name\",\n"
+                      "               \"toolchain_version_epoch\",\n"
+                      "               \"toolchain_version_canonical_upstream\",\n"
+                      "               \"toolchain_version_canonical_release\",\n"
+                      "               \"toolchain_version_revision\"))");
+          db.execute ("CREATE INDEX \"build_timestamp_i\"\n"
+                      "  ON \"build\" (\"timestamp\")");
+          db.execute ("CREATE TABLE \"build_results\" (\n"
+                      "  \"package_tenant\" TEXT NOT NULL,\n"
+                      "  \"package_name\" CITEXT NOT NULL,\n"
+                      "  \"package_version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"package_version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"package_version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"package_version_revision\" INTEGER NOT NULL,\n"
+                      "  \"configuration\" TEXT NOT NULL,\n"
+                      "  \"toolchain_name\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"toolchain_version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"toolchain_version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"operation\" TEXT NOT NULL,\n"
+                      "  \"status\" TEXT NOT NULL,\n"
+                      "  \"log\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"package_tenant\",\n"
+                      "                 \"package_name\",\n"
+                      "                 \"package_version_epoch\",\n"
+                      "                 \"package_version_canonical_upstream\",\n"
+                      "                 \"package_version_canonical_release\",\n"
+                      "                 \"package_version_revision\",\n"
+                      "                 \"configuration\",\n"
+                      "                 \"toolchain_name\",\n"
+                      "                 \"toolchain_version_epoch\",\n"
+                      "                 \"toolchain_version_canonical_upstream\",\n"
+                      "                 \"toolchain_version_canonical_release\",\n"
+                      "                 \"toolchain_version_revision\")\n"
+                      "    REFERENCES \"build\" (\"package_tenant\",\n"
+                      "                        \"package_name\",\n"
+                      "                        \"package_version_epoch\",\n"
+                      "                        \"package_version_canonical_upstream\",\n"
+                      "                        \"package_version_canonical_release\",\n"
+                      "                        \"package_version_revision\",\n"
+                      "                        \"configuration\",\n"
+                      "                        \"toolchain_name\",\n"
+                      "                        \"toolchain_version_epoch\",\n"
+                      "                        \"toolchain_version_canonical_upstream\",\n"
+                      "                        \"toolchain_version_canonical_release\",\n"
+                      "                        \"toolchain_version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"build_results_object_id_i\"\n"
+                      "  ON \"build_results\" (\n"
+                      "    \"package_tenant\",\n"
+                      "    \"package_name\",\n"
+                      "    \"package_version_epoch\",\n"
+                      "    \"package_version_canonical_upstream\",\n"
+                      "    \"package_version_canonical_release\",\n"
+                      "    \"package_version_revision\",\n"
+                      "    \"configuration\",\n"
+                      "    \"toolchain_name\",\n"
+                      "    \"toolchain_version_epoch\",\n"
+                      "    \"toolchain_version_canonical_upstream\",\n"
+                      "    \"toolchain_version_canonical_release\",\n"
+                      "    \"toolchain_version_revision\")");
+          db.execute ("CREATE INDEX \"build_results_index_i\"\n"
+                      "  ON \"build_results\" (\"index\")");
+          db.execute ("CREATE TABLE \"build_delay\" (\n"
+                      "  \"package_tenant\" TEXT NOT NULL,\n"
+                      "  \"package_name\" CITEXT NOT NULL,\n"
+                      "  \"package_version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"package_version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"package_version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"package_version_revision\" INTEGER NOT NULL,\n"
+                      "  \"configuration\" TEXT NOT NULL,\n"
+                      "  \"toolchain_name\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"toolchain_version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"toolchain_version_revision\" INTEGER NOT NULL,\n"
+                      "  \"package_version_upstream\" TEXT NOT NULL,\n"
+                      "  \"package_version_release\" TEXT NULL,\n"
+                      "  \"toolchain_version_upstream\" TEXT NOT NULL,\n"
+                      "  \"toolchain_version_release\" TEXT NULL,\n"
+                      "  \"report_timestamp\" BIGINT NOT NULL,\n"
+                      "  \"package_timestamp\" BIGINT NOT NULL,\n"
+                      "  PRIMARY KEY (\"package_tenant\",\n"
+                      "               \"package_name\",\n"
+                      "               \"package_version_epoch\",\n"
+                      "               \"package_version_canonical_upstream\",\n"
+                      "               \"package_version_canonical_release\",\n"
+                      "               \"package_version_revision\",\n"
+                      "               \"configuration\",\n"
+                      "               \"toolchain_name\",\n"
+                      "               \"toolchain_version_epoch\",\n"
+                      "               \"toolchain_version_canonical_upstream\",\n"
+                      "               \"toolchain_version_canonical_release\",\n"
+                      "               \"toolchain_version_revision\"))");
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("CREATE TABLE \"schema_version\" (\n"
+                      "  \"name\" TEXT NOT NULL PRIMARY KEY,\n"
+                      "  \"version\" BIGINT NOT NULL,\n"
+                      "  \"migration\" BOOLEAN NOT NULL)");
+          db.execute ("INSERT INTO \"schema_version\" (\n"
+                      "  \"name\", \"version\", \"migration\")\n"
+                      "  VALUES ('build', 12, FALSE)");
+          return false;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  static const schema_catalog_create_entry
+  create_schema_entry_ (
+    id_pgsql,
+    "build",
+    &create_schema);
+
+  static const schema_catalog_migrate_entry
+  migrate_schema_entry_12_ (
+    id_pgsql,
+    "build",
+    12ULL,
+    0);
+}
+
+#include <odb/post.hxx>
diff --git a/libbrep/build-odb.hxx b/libbrep/build-odb.hxx
new file mode 100644
index 0000000..9000a24
--- /dev/null
+++ b/libbrep/build-odb.hxx
@@ -0,0 +1,2056 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#ifndef LIBBREP_BUILD_ODB_HXX
+#define LIBBREP_BUILD_ODB_HXX
+
+#include <odb/version.hxx>
+
+#if (ODB_VERSION != 20470UL)
+#error ODB runtime version mismatch
+#endif
+
+#include <odb/pre.hxx>
+
+#include <libbrep/build.hxx>
+
+#include <libbrep/build-package-odb.hxx>
+#include <libbrep/common-odb.hxx>
+
+#include <memory>
+#include <cstddef>
+#include <utility>
+
+#include <odb/core.hxx>
+#include <odb/traits.hxx>
+#include <odb/callback.hxx>
+#include <odb/wrapper-traits.hxx>
+#include <odb/pointer-traits.hxx>
+#include <odb/container-traits.hxx>
+#include <odb/session.hxx>
+#include <odb/cache-traits.hxx>
+#include <odb/prepared-query.hxx>
+#include <odb/result.hxx>
+#include <odb/simple-object-result.hxx>
+#include <odb/view-image.hxx>
+#include <odb/view-result.hxx>
+
+#include <odb/details/unused.hxx>
+#include <odb/details/shared-ptr.hxx>
+
+namespace odb
+{
+  // build
+  //
+  template <>
+  struct class_traits< ::brep::build >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::build >
+  {
+    public:
+    typedef ::brep::build object_type;
+    typedef ::std::shared_ptr< ::brep::build > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::brep::build_id id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // toolchain
+  //
+  template <>
+  struct class_traits< ::brep::toolchain >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::toolchain >
+  {
+    public:
+    typedef ::brep::toolchain view_type;
+    typedef ::brep::toolchain* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // package_build
+  //
+  template <>
+  struct class_traits< ::brep::package_build >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::package_build >
+  {
+    public:
+    typedef ::brep::package_build view_type;
+    typedef ::brep::package_build* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // package_build_count
+  //
+  template <>
+  struct class_traits< ::brep::package_build_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::package_build_count >
+  {
+    public:
+    typedef ::brep::package_build_count view_type;
+    typedef ::brep::package_build_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // build_delay
+  //
+  template <>
+  struct class_traits< ::brep::build_delay >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::build_delay >
+  {
+    public:
+    typedef ::brep::build_delay object_type;
+    typedef ::std::shared_ptr< ::brep::build_delay > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::brep::build_id id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+}
+
+#include <odb/details/buffer.hxx>
+
+#include <odb/pgsql/version.hxx>
+#include <odb/pgsql/forward.hxx>
+#include <odb/pgsql/binding.hxx>
+#include <odb/pgsql/pgsql-types.hxx>
+#include <odb/pgsql/query.hxx>
+
+namespace odb
+{
+  // operation_result
+  //
+  template <>
+  class access::composite_value_traits< ::bbot::operation_result, id_pgsql >
+  {
+    public:
+    typedef ::bbot::operation_result value_type;
+
+    struct image_type
+    {
+      // operation
+      //
+      details::buffer operation_value;
+      std::size_t operation_size;
+      bool operation_null;
+
+      // status
+      //
+      details::buffer status_value;
+      std::size_t status_size;
+      bool status_null;
+
+      // log
+      //
+      details::buffer log_value;
+      std::size_t log_size;
+      bool log_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 3UL;
+  };
+
+  // build_id
+  //
+  template <>
+  class access::composite_value_traits< ::brep::build_id, id_pgsql >
+  {
+    public:
+    typedef ::brep::build_id value_type;
+
+    struct image_type
+    {
+      // package
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type package_value;
+
+      // configuration
+      //
+      details::buffer configuration_value;
+      std::size_t configuration_size;
+      bool configuration_null;
+
+      // toolchain_name
+      //
+      details::buffer toolchain_name_value;
+      std::size_t toolchain_name_size;
+      bool toolchain_name_null;
+
+      // toolchain_version
+      //
+      composite_value_traits< ::brep::canonical_version, id_pgsql >::image_type toolchain_version_value;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 12UL;
+  };
+
+  // build
+  //
+  template <typename A>
+  struct query_columns< ::brep::build, id_pgsql, A >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // package
+      //
+      struct package_class_1_
+      {
+        package_class_1_ ()
+        {
+        }
+
+        // tenant
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        tenant_type_;
+
+        static const tenant_type_ tenant;
+
+        // name
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::bpkg::package_name,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        name_type_;
+
+        static const name_type_ name;
+
+        // version
+        //
+        struct version_class_2_
+        {
+          version_class_2_ ()
+          {
+          }
+
+          // epoch
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::uint16_t,
+              pgsql::id_integer >::query_type,
+            pgsql::id_integer >
+          epoch_type_;
+
+          static const epoch_type_ epoch;
+
+          // canonical_upstream
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::std::string,
+              pgsql::id_string >::query_type,
+            pgsql::id_string >
+          canonical_upstream_type_;
+
+          static const canonical_upstream_type_ canonical_upstream;
+
+          // canonical_release
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::std::string,
+              pgsql::id_string >::query_type,
+            pgsql::id_string >
+          canonical_release_type_;
+
+          static const canonical_release_type_ canonical_release;
+
+          // revision
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::uint16_t,
+              pgsql::id_integer >::query_type,
+            pgsql::id_integer >
+          revision_type_;
+
+          static const revision_type_ revision;
+        };
+
+        static const version_class_2_ version;
+      };
+
+      static const package_class_1_ package;
+
+      // configuration
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      configuration_type_;
+
+      static const configuration_type_ configuration;
+
+      // toolchain_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      toolchain_name_type_;
+
+      static const toolchain_name_type_ toolchain_name;
+
+      // toolchain_version
+      //
+      struct toolchain_version_class_1_
+      {
+        toolchain_version_class_1_ ()
+        {
+        }
+
+        // epoch
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        epoch_type_;
+
+        static const epoch_type_ epoch;
+
+        // canonical_upstream
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_upstream_type_;
+
+        static const canonical_upstream_type_ canonical_upstream;
+
+        // canonical_release
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_release_type_;
+
+        static const canonical_release_type_ canonical_release;
+
+        // revision
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        revision_type_;
+
+        static const revision_type_ revision;
+      };
+
+      static const toolchain_version_class_1_ toolchain_version;
+    };
+
+    static const id_class_ id;
+
+    // package_version
+    //
+    struct package_version_class_
+    {
+      package_version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const package_version_class_ package_version;
+
+    // toolchain_version
+    //
+    struct toolchain_version_class_
+    {
+      toolchain_version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const toolchain_version_class_ toolchain_version;
+
+    // state
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    state_type_;
+
+    static const state_type_ state;
+
+    // timestamp
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint64_t,
+        pgsql::id_bigint >::query_type,
+      pgsql::id_bigint >
+    timestamp_type_;
+
+    static const timestamp_type_ timestamp;
+
+    // force
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    force_type_;
+
+    static const force_type_ force;
+
+    // status
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    status_type_;
+
+    static const status_type_ status;
+
+    // completion_timestamp
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint64_t,
+        pgsql::id_bigint >::query_type,
+      pgsql::id_bigint >
+    completion_timestamp_type_;
+
+    static const completion_timestamp_type_ completion_timestamp;
+
+    // agent_fingerprint
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    agent_fingerprint_type_;
+
+    static const agent_fingerprint_type_ agent_fingerprint;
+
+    // agent_challenge
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    agent_challenge_type_;
+
+    static const agent_challenge_type_ agent_challenge;
+
+    // machine
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    machine_type_;
+
+    static const machine_type_ machine;
+
+    // machine_summary
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    machine_summary_type_;
+
+    static const machine_summary_type_ machine_summary;
+
+    // target
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    target_type_;
+
+    static const target_type_ target;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::tenant_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::
+  tenant (A::table_name, "\"package_tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::name_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::
+  name (A::table_name, "\"package_name\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::epoch_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  epoch (A::table_name, "\"package_version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::canonical_upstream_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  canonical_upstream (A::table_name, "\"package_version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::canonical_release_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  canonical_release (A::table_name, "\"package_version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::revision_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  revision (A::table_name, "\"package_version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version_class_2_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_::version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::package_class_1_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::package;
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::configuration_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::
+  configuration (A::table_name, "\"configuration\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_name_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::
+  toolchain_name (A::table_name, "\"toolchain_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::epoch_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  epoch (A::table_name, "\"toolchain_version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::canonical_upstream_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  canonical_upstream (A::table_name, "\"toolchain_version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::canonical_release_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  canonical_release (A::table_name, "\"toolchain_version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::revision_type_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  revision (A::table_name, "\"toolchain_version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version_class_1_
+  query_columns< ::brep::build, id_pgsql, A >::id_class_::toolchain_version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::id_class_
+  query_columns< ::brep::build, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::package_version_class_::upstream_type_
+  query_columns< ::brep::build, id_pgsql, A >::package_version_class_::
+  upstream (A::table_name, "\"package_version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::package_version_class_::release_type_
+  query_columns< ::brep::build, id_pgsql, A >::package_version_class_::
+  release (A::table_name, "\"package_version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::package_version_class_
+  query_columns< ::brep::build, id_pgsql, A >::package_version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::toolchain_version_class_::upstream_type_
+  query_columns< ::brep::build, id_pgsql, A >::toolchain_version_class_::
+  upstream (A::table_name, "\"toolchain_version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::toolchain_version_class_::release_type_
+  query_columns< ::brep::build, id_pgsql, A >::toolchain_version_class_::
+  release (A::table_name, "\"toolchain_version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::toolchain_version_class_
+  query_columns< ::brep::build, id_pgsql, A >::toolchain_version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::state_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  state (A::table_name, "\"state\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::timestamp_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  timestamp (A::table_name, "\"timestamp\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::force_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  force (A::table_name, "\"force\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::status_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  status (A::table_name, "\"status\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::completion_timestamp_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  completion_timestamp (A::table_name, "\"completion_timestamp\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::agent_fingerprint_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  agent_fingerprint (A::table_name, "\"agent_fingerprint\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::agent_challenge_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  agent_challenge (A::table_name, "\"agent_challenge\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::machine_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  machine (A::table_name, "\"machine\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::machine_summary_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  machine_summary (A::table_name, "\"machine_summary\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build, id_pgsql, A >::target_type_
+  query_columns< ::brep::build, id_pgsql, A >::
+  target (A::table_name, "\"target\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::brep::build, id_pgsql, A >:
+    query_columns< ::brep::build, id_pgsql, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build, id_pgsql >:
+    public access::object_traits< ::brep::build >
+  {
+    public:
+    struct id_image_type
+    {
+      composite_value_traits< ::brep::build_id, id_pgsql >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::build_id, id_pgsql >::image_type id_value;
+
+      // package_version
+      //
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::image_type package_version_value;
+
+      // toolchain_version
+      //
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::image_type toolchain_version_value;
+
+      // state
+      //
+      details::buffer state_value;
+      std::size_t state_size;
+      bool state_null;
+
+      // timestamp
+      //
+      long long timestamp_value;
+      bool timestamp_null;
+
+      // force
+      //
+      details::buffer force_value;
+      std::size_t force_size;
+      bool force_null;
+
+      // status
+      //
+      details::buffer status_value;
+      std::size_t status_size;
+      bool status_null;
+
+      // completion_timestamp
+      //
+      long long completion_timestamp_value;
+      bool completion_timestamp_null;
+
+      // agent_fingerprint
+      //
+      details::buffer agent_fingerprint_value;
+      std::size_t agent_fingerprint_size;
+      bool agent_fingerprint_null;
+
+      // agent_challenge
+      //
+      details::buffer agent_challenge_value;
+      std::size_t agent_challenge_size;
+      bool agent_challenge_null;
+
+      // machine
+      //
+      details::buffer machine_value;
+      std::size_t machine_size;
+      bool machine_null;
+
+      // machine_summary
+      //
+      details::buffer machine_summary_value;
+      std::size_t machine_summary_size;
+      bool machine_summary_null;
+
+      // target
+      //
+      details::buffer target_value;
+      std::size_t target_size;
+      bool target_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // results
+    //
+    struct results_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 12UL;
+      static const std::size_t data_column_count = 16UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::bbot::operation_results container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< results_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // results_section
+    //
+    struct results_section_traits
+    {
+      typedef object_traits_impl<object_type, id_pgsql>::image_type image_type;
+      typedef object_traits_impl<object_type, id_pgsql>::id_image_type id_image_type;
+
+      static const std::size_t id_column_count = 12UL;
+      static const std::size_t managed_optimistic_load_column_count = 0UL;
+      static const std::size_t load_column_count = 0UL;
+      static const std::size_t managed_optimistic_update_column_count = 0UL;
+      static const std::size_t update_column_count = 0UL;
+
+      static const bool versioned = false;
+
+      static void
+      load (extra_statement_cache_type&, object_type&);
+
+      static void
+      update (extra_statement_cache_type&, const object_type&);
+    };
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 26UL;
+    static const std::size_t id_column_count = 12UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static bool
+    load (connection&, object_type&, section&);
+
+    static bool
+    update (connection&, const object_type&, const section&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char update_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+    static const unsigned int update_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build, id_common >:
+    public access::object_traits_impl< ::brep::build, id_pgsql >
+  {
+  };
+
+  // toolchain
+  //
+  template <>
+  class access::view_traits_impl< ::brep::toolchain, id_pgsql >:
+    public access::view_traits< ::brep::toolchain >
+  {
+    public:
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // epoch
+      //
+      int epoch_value;
+      bool epoch_null;
+
+      // canonical_upstream
+      //
+      details::buffer canonical_upstream_value;
+      std::size_t canonical_upstream_size;
+      bool canonical_upstream_null;
+
+      // canonical_release
+      //
+      details::buffer canonical_release_value;
+      std::size_t canonical_release_size;
+      bool canonical_release_null;
+
+      // revision
+      //
+      int revision_value;
+      bool revision_null;
+
+      // version
+      //
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::image_type version_value;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 7UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::toolchain, id_common >:
+    public access::view_traits_impl< ::brep::toolchain, id_pgsql >
+  {
+  };
+
+  // package_build
+  //
+  template <>
+  class access::view_traits_impl< ::brep::package_build, id_pgsql >:
+    public access::view_traits< ::brep::package_build >
+  {
+    public:
+    struct image_type
+    {
+      // build
+      //
+      object_traits_impl< ::brep::build, id_pgsql >::image_type build_value;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 26UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::package_build, id_common >:
+    public access::view_traits_impl< ::brep::package_build, id_pgsql >
+  {
+  };
+
+  // package_build_count
+  //
+  template <>
+  class access::view_traits_impl< ::brep::package_build_count, id_pgsql >:
+    public access::view_traits< ::brep::package_build_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::package_build_count, id_common >:
+    public access::view_traits_impl< ::brep::package_build_count, id_pgsql >
+  {
+  };
+
+  // build_delay
+  //
+  template <typename A>
+  struct query_columns< ::brep::build_delay, id_pgsql, A >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // package
+      //
+      struct package_class_1_
+      {
+        package_class_1_ ()
+        {
+        }
+
+        // tenant
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        tenant_type_;
+
+        static const tenant_type_ tenant;
+
+        // name
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::bpkg::package_name,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        name_type_;
+
+        static const name_type_ name;
+
+        // version
+        //
+        struct version_class_2_
+        {
+          version_class_2_ ()
+          {
+          }
+
+          // epoch
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::uint16_t,
+              pgsql::id_integer >::query_type,
+            pgsql::id_integer >
+          epoch_type_;
+
+          static const epoch_type_ epoch;
+
+          // canonical_upstream
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::std::string,
+              pgsql::id_string >::query_type,
+            pgsql::id_string >
+          canonical_upstream_type_;
+
+          static const canonical_upstream_type_ canonical_upstream;
+
+          // canonical_release
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::std::string,
+              pgsql::id_string >::query_type,
+            pgsql::id_string >
+          canonical_release_type_;
+
+          static const canonical_release_type_ canonical_release;
+
+          // revision
+          //
+          typedef
+          pgsql::query_column<
+            pgsql::value_traits<
+              ::uint16_t,
+              pgsql::id_integer >::query_type,
+            pgsql::id_integer >
+          revision_type_;
+
+          static const revision_type_ revision;
+        };
+
+        static const version_class_2_ version;
+      };
+
+      static const package_class_1_ package;
+
+      // configuration
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      configuration_type_;
+
+      static const configuration_type_ configuration;
+
+      // toolchain_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      toolchain_name_type_;
+
+      static const toolchain_name_type_ toolchain_name;
+
+      // toolchain_version
+      //
+      struct toolchain_version_class_1_
+      {
+        toolchain_version_class_1_ ()
+        {
+        }
+
+        // epoch
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        epoch_type_;
+
+        static const epoch_type_ epoch;
+
+        // canonical_upstream
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_upstream_type_;
+
+        static const canonical_upstream_type_ canonical_upstream;
+
+        // canonical_release
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_release_type_;
+
+        static const canonical_release_type_ canonical_release;
+
+        // revision
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        revision_type_;
+
+        static const revision_type_ revision;
+      };
+
+      static const toolchain_version_class_1_ toolchain_version;
+    };
+
+    static const id_class_ id;
+
+    // package_version
+    //
+    struct package_version_class_
+    {
+      package_version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const package_version_class_ package_version;
+
+    // toolchain_version
+    //
+    struct toolchain_version_class_
+    {
+      toolchain_version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const toolchain_version_class_ toolchain_version;
+
+    // report_timestamp
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint64_t,
+        pgsql::id_bigint >::query_type,
+      pgsql::id_bigint >
+    report_timestamp_type_;
+
+    static const report_timestamp_type_ report_timestamp;
+
+    // package_timestamp
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint64_t,
+        pgsql::id_bigint >::query_type,
+      pgsql::id_bigint >
+    package_timestamp_type_;
+
+    static const package_timestamp_type_ package_timestamp;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::tenant_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::
+  tenant (A::table_name, "\"package_tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::name_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::
+  name (A::table_name, "\"package_name\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::epoch_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  epoch (A::table_name, "\"package_version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::canonical_upstream_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  canonical_upstream (A::table_name, "\"package_version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::canonical_release_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  canonical_release (A::table_name, "\"package_version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::revision_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_::
+  revision (A::table_name, "\"package_version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version_class_2_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_::version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package_class_1_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::package;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::configuration_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::
+  configuration (A::table_name, "\"configuration\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_name_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::
+  toolchain_name (A::table_name, "\"toolchain_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::epoch_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  epoch (A::table_name, "\"toolchain_version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::canonical_upstream_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  canonical_upstream (A::table_name, "\"toolchain_version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::canonical_release_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  canonical_release (A::table_name, "\"toolchain_version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::revision_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_::
+  revision (A::table_name, "\"toolchain_version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version_class_1_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id_class_::toolchain_version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::id_class_
+  query_columns< ::brep::build_delay, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::package_version_class_::upstream_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::package_version_class_::
+  upstream (A::table_name, "\"package_version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::package_version_class_::release_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::package_version_class_::
+  release (A::table_name, "\"package_version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::package_version_class_
+  query_columns< ::brep::build_delay, id_pgsql, A >::package_version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::toolchain_version_class_::upstream_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::toolchain_version_class_::
+  upstream (A::table_name, "\"toolchain_version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::toolchain_version_class_::release_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::toolchain_version_class_::
+  release (A::table_name, "\"toolchain_version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::toolchain_version_class_
+  query_columns< ::brep::build_delay, id_pgsql, A >::toolchain_version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::report_timestamp_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::
+  report_timestamp (A::table_name, "\"report_timestamp\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_delay, id_pgsql, A >::package_timestamp_type_
+  query_columns< ::brep::build_delay, id_pgsql, A >::
+  package_timestamp (A::table_name, "\"package_timestamp\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::brep::build_delay, id_pgsql, A >:
+    query_columns< ::brep::build_delay, id_pgsql, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build_delay, id_pgsql >:
+    public access::object_traits< ::brep::build_delay >
+  {
+    public:
+    struct id_image_type
+    {
+      composite_value_traits< ::brep::build_id, id_pgsql >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::build_id, id_pgsql >::image_type id_value;
+
+      // package_version
+      //
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::image_type package_version_value;
+
+      // toolchain_version
+      //
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::image_type toolchain_version_value;
+
+      // report_timestamp
+      //
+      long long report_timestamp_value;
+      bool report_timestamp_null;
+
+      // package_timestamp
+      //
+      long long package_timestamp_value;
+      bool package_timestamp_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 18UL;
+    static const std::size_t id_column_count = 12UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char update_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+    static const unsigned int update_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build_delay, id_common >:
+    public access::object_traits_impl< ::brep::build_delay, id_pgsql >
+  {
+  };
+
+  // build
+  //
+  // toolchain
+  //
+  struct access::view_traits_impl< ::brep::toolchain, id_pgsql >::query_columns
+  {
+    // build
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build, id_pgsql > >
+    build;
+
+    // build_package
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_package,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_package, id_pgsql > >
+    build_package;
+  };
+
+  // package_build
+  //
+  struct access::view_traits_impl< ::brep::package_build, id_pgsql >::query_columns
+  {
+    // build
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build, id_pgsql > >
+    build;
+
+    // build_package
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_package,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_package, id_pgsql > >
+    build_package;
+
+    // build_tenant
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_tenant,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_tenant, id_pgsql > >
+    build_tenant;
+  };
+
+  // package_build_count
+  //
+  struct access::view_traits_impl< ::brep::package_build_count, id_pgsql >::query_columns
+  {
+    // build
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build, id_pgsql > >
+    build;
+
+    // build_package
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_package,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_package, id_pgsql > >
+    build_package;
+
+    // build_tenant
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_tenant,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_tenant, id_pgsql > >
+    build_tenant;
+  };
+
+  // build_delay
+  //
+}
+
+#include <libbrep/build-odb.ixx>
+
+#include <odb/post.hxx>
+
+#endif // LIBBREP_BUILD_ODB_HXX
diff --git a/libbrep/build-odb.ixx b/libbrep/build-odb.ixx
new file mode 100644
index 0000000..a1fe977
--- /dev/null
+++ b/libbrep/build-odb.ixx
@@ -0,0 +1,207 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+namespace odb
+{
+  // build
+  //
+
+  inline
+  access::object_traits< ::brep::build >::id_type
+  access::object_traits< ::brep::build >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::build >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::build >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // toolchain
+  //
+
+  inline
+  void access::view_traits< ::brep::toolchain >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // package_build
+  //
+
+  inline
+  void access::view_traits< ::brep::package_build >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // package_build_count
+  //
+
+  inline
+  void access::view_traits< ::brep::package_build_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // build_delay
+  //
+
+  inline
+  access::object_traits< ::brep::build_delay >::id_type
+  access::object_traits< ::brep::build_delay >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::build_delay >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::build_delay >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+}
+
+namespace odb
+{
+  // operation_result
+  //
+
+  inline
+  bool access::composite_value_traits< ::bbot::operation_result, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.operation_null;
+    r = r && i.status_null;
+    r = r && i.log_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bbot::operation_result, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.operation_null = true;
+    i.status_null = true;
+    i.log_null = true;
+  }
+
+  // build_id
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::build_id, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && composite_value_traits< ::brep::package_id, id_pgsql >::get_null (i.package_value);
+    r = r && i.configuration_null;
+    r = r && i.toolchain_name_null;
+    r = r && composite_value_traits< ::brep::canonical_version, id_pgsql >::get_null (i.toolchain_version_value);
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::build_id, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    composite_value_traits< ::brep::package_id, id_pgsql >::set_null (i.package_value, sk);
+    i.configuration_null = true;
+    i.toolchain_name_null = true;
+    composite_value_traits< ::brep::canonical_version, id_pgsql >::set_null (i.toolchain_version_value, sk);
+  }
+
+  // build
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::build, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // toolchain
+  //
+
+  // package_build
+  //
+
+  // package_build_count
+  //
+
+  // build_delay
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  inline
+  void access::object_traits_impl< ::brep::build_delay, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool)
+  {
+    ODB_POTENTIALLY_UNUSED (sts);
+    ODB_POTENTIALLY_UNUSED (obj);
+  }
+}
+
diff --git a/libbrep/build-package-odb.cxx b/libbrep/build-package-odb.cxx
new file mode 100644
index 0000000..8b6e3ca
--- /dev/null
+++ b/libbrep/build-package-odb.cxx
@@ -0,0 +1,3988 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#include <odb/pre.hxx>
+
+#include <libbrep/build-package-odb.hxx>
+
+#include <cassert>
+#include <cstring>  // std::memcpy
+
+
+#include <odb/pgsql/traits.hxx>
+#include <odb/pgsql/database.hxx>
+#include <odb/pgsql/transaction.hxx>
+#include <odb/pgsql/connection.hxx>
+#include <odb/pgsql/statement.hxx>
+#include <odb/pgsql/statement-cache.hxx>
+#include <odb/pgsql/simple-object-statements.hxx>
+#include <odb/pgsql/view-statements.hxx>
+#include <odb/pgsql/container-statements.hxx>
+#include <odb/pgsql/exceptions.hxx>
+#include <odb/pgsql/prepared-query.hxx>
+#include <odb/pgsql/simple-object-result.hxx>
+#include <odb/pgsql/view-result.hxx>
+
+namespace odb
+{
+  // build_tenant
+  //
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  persist_statement_name[] = "persist_brep_build_tenant";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  find_statement_name[] = "find_brep_build_tenant";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  erase_statement_name[] = "erase_brep_build_tenant";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  query_statement_name[] = "query_brep_build_tenant";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_build_tenant";
+
+  const unsigned int access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::bool_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid
+  };
+
+  struct access::object_traits_impl< ::brep::build_tenant, id_pgsql >::extra_statement_cache_type
+  {
+    extra_statement_cache_type (
+      pgsql::connection&,
+      image_type&,
+      id_image_type&,
+      pgsql::binding&,
+      pgsql::binding&,
+      pgsql::native_binding&,
+      const unsigned int*)
+    {
+    }
+  };
+
+  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        id,
+        i.id_value,
+        i.id_size,
+        i.id_null);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (t[0UL])
+    {
+      i.id_value.capacity (i.id_size);
+      grew = true;
+    }
+
+    // archived
+    //
+    t[1UL] = 0;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    assert (sk != statement_update);
+
+    std::size_t n (0);
+
+    // id
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.id_value.data ();
+    b[n].capacity = i.id_value.capacity ();
+    b[n].size = &i.id_size;
+    b[n].is_null = &i.id_null;
+    n++;
+
+    // archived
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.archived_value;
+    b[n].is_null = &i.archived_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.id_value.data ();
+    b[n].capacity = i.id_value.capacity ();
+    b[n].size = &i.id_size;
+    b[n].is_null = &i.id_null;
+  }
+
+  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    assert (sk != statement_update);
+
+    bool grew (false);
+
+    // id
+    //
+    {
+      ::std::string const& v =
+        o.id;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.id_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.id_value,
+        size,
+        is_null,
+        v);
+      i.id_null = is_null;
+      i.id_size = size;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    // archived
+    //
+    {
+      bool const& v =
+        o.archived;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.archived_value, is_null, v);
+      i.archived_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::std::string& v =
+        o.id;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.id_value,
+        i.id_size,
+        i.id_null);
+    }
+
+    // archived
+    //
+    {
+      bool& v =
+        o.archived;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.archived_value,
+        i.archived_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    {
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.id_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.id_value,
+        size,
+        is_null,
+        id);
+      i.id_null = is_null;
+      i.id_size = size;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"build_tenant\" "
+  "(\"id\", "
+  "\"archived\") "
+  "VALUES "
+  "($1, $2)";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"build_tenant\".\"id\", "
+  "\"build_tenant\".\"archived\" "
+  "FROM \"build_tenant\" "
+  "WHERE \"build_tenant\".\"id\"=$1";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"build_tenant\" "
+  "WHERE \"id\"=$1";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::query_statement[] =
+  "SELECT "
+  "\"build_tenant\".\"id\", "
+  "\"build_tenant\".\"archived\" "
+  "FROM \"build_tenant\"";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"build_tenant\"";
+
+  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::table_name[] =
+  "\"build_tenant\"";
+
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  result< access::object_traits_impl< ::brep::build_tenant, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        false,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // build_repository
+  //
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  persist_statement_name[] = "persist_brep_build_repository";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  find_statement_name[] = "find_brep_build_repository";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  erase_statement_name[] = "erase_brep_build_repository";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  query_statement_name[] = "query_brep_build_repository";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_build_repository";
+
+  const unsigned int access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  struct access::object_traits_impl< ::brep::build_repository, id_pgsql >::extra_statement_cache_type
+  {
+    extra_statement_cache_type (
+      pgsql::connection&,
+      image_type&,
+      id_image_type&,
+      pgsql::binding&,
+      pgsql::binding&,
+      pgsql::native_binding&,
+      const unsigned int*)
+    {
+    }
+  };
+
+  access::object_traits_impl< ::brep::build_repository, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+        id,
+        i.id_value,
+        db);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // location
+    //
+    if (composite_value_traits< ::brep::_repository_location, id_pgsql >::grow (
+          i.location_value, t + 2UL))
+      grew = true;
+
+    // certificate_fingerprint
+    //
+    if (t[4UL])
+    {
+      i.certificate_fingerprint_value.capacity (i.certificate_fingerprint_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    assert (sk != statement_update);
+
+    std::size_t n (0);
+
+    // id
+    //
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+    n += 2UL;
+
+    // location
+    //
+    composite_value_traits< ::brep::_repository_location, id_pgsql >::bind (
+      b + n, i.location_value, sk);
+    n += 2UL;
+
+    // certificate_fingerprint
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.certificate_fingerprint_value.data ();
+    b[n].capacity = i.certificate_fingerprint_value.capacity ();
+    b[n].size = &i.certificate_fingerprint_size;
+    b[n].is_null = &i.certificate_fingerprint_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+  }
+
+  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    assert (sk != statement_update);
+
+    bool grew (false);
+
+    // id
+    //
+    {
+      ::brep::repository_id const& v =
+        o.id;
+
+      if (composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+            i.id_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // location
+    //
+    {
+      ::bpkg::repository_location const& v =
+        o.location;
+
+      // From common.hxx:285:14
+      ::brep::_repository_location const& vt =
+        brep::_repository_location 
+      {
+         (v).url (), (v).empty () ? brep::repository_type::pkg : (v).type () 
+      };
+
+
+      if (composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
+            i.location_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    // certificate_fingerprint
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.certificate_fingerprint;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.certificate_fingerprint_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.certificate_fingerprint_value,
+        size,
+        is_null,
+        v);
+      i.certificate_fingerprint_null = is_null;
+      i.certificate_fingerprint_size = size;
+      grew = grew || (cap != i.certificate_fingerprint_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::repository_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // location
+    //
+    {
+      // From build-package.hxx:63:7
+      ::bpkg::repository_location v;
+
+      ::brep::_repository_location vt;
+
+      composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
+        vt,
+        i.location_value,
+        db);
+
+      // From common.hxx:285:14
+      v = brep::repository_location (std::move ((vt).url), (vt).type);
+      // From build-package.hxx:63:7
+      o.location = std::move (v);
+      assert (o.canonical_name == o.location.canonical_name ());
+    }
+
+    // certificate_fingerprint
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.certificate_fingerprint;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.certificate_fingerprint_value,
+        i.certificate_fingerprint_size,
+        i.certificate_fingerprint_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    {
+      if (composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+            i.id_value,
+            id,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"build_repository\" "
+  "(\"tenant\", "
+  "\"canonical_name\", "
+  "\"location_url\", "
+  "\"location_type\", "
+  "\"certificate_fingerprint\") "
+  "VALUES "
+  "($1, $2, $3, $4, $5)";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"build_repository\".\"tenant\", "
+  "\"build_repository\".\"canonical_name\", "
+  "\"build_repository\".\"location_url\", "
+  "\"build_repository\".\"location_type\", "
+  "\"build_repository\".\"certificate_fingerprint\" "
+  "FROM \"build_repository\" "
+  "WHERE \"build_repository\".\"tenant\"=$1 AND \"build_repository\".\"canonical_name\"=$2";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"build_repository\" "
+  "WHERE \"tenant\"=$1 AND \"canonical_name\"=$2";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::query_statement[] =
+  "SELECT "
+  "\"build_repository\".\"tenant\", "
+  "\"build_repository\".\"canonical_name\", "
+  "\"build_repository\".\"location_url\", "
+  "\"build_repository\".\"location_type\", "
+  "\"build_repository\".\"certificate_fingerprint\" "
+  "FROM \"build_repository\"";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"build_repository\"";
+
+  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::table_name[] =
+  "\"build_repository\"";
+
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::build_repository, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  result< access::object_traits_impl< ::brep::build_repository, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        false,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // build_test_dependency
+  //
+
+  bool access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // package
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.package_value, t + 1UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.name_value.data ();
+    b[n].capacity = i.name_value.capacity ();
+    b[n].size = &i.name_size;
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // package
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.package_value, sk);
+    n += 6UL;
+  }
+
+  bool access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // name
+    //
+    {
+      ::bpkg::package_name const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.name_value.capacity ());
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_image (
+        i.name_value,
+        size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      i.name_size = size;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // package
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::build_package > const& v =
+        o.package;
+
+      typedef object_traits< ::brep::build_package > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_package > > ptr_traits;
+
+      bool is_null (ptr_traits::null_ptr (v));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (v));
+
+        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+              i.package_value,
+              ptr_id,
+              sk))
+          grew = true;
+      }
+      else
+        composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.package_value, sk);
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::bpkg::package_name& v =
+        o.name;
+
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // package
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::build_package >& v =
+        o.package;
+
+      typedef object_traits< ::brep::build_package > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_package > > ptr_traits;
+
+      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
+            i.package_value))
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+          ptr_id,
+          i.package_value,
+          db);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<pgsql::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  // build_package
+  //
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  persist_statement_name[] = "persist_brep_build_package";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  find_statement_name[] = "find_brep_build_package";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  erase_statement_name[] = "erase_brep_build_package";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  query_statement_name[] = "query_brep_build_package";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_build_package";
+
+  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::bool_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  const char alias_traits<  ::brep::build_repository,
+    id_pgsql,
+    access::object_traits_impl< ::brep::build_package, id_pgsql >::internal_repository_tag>::
+  table_name[] = "\"internal_repository\"";
+
+  struct access::object_traits_impl< ::brep::build_package, id_pgsql >::extra_statement_cache_type
+  {
+    pgsql::container_statements_impl< tests_traits > tests;
+    pgsql::container_statements_impl< builds_traits > builds;
+    pgsql::container_statements_impl< constraints_traits > constraints;
+
+    extra_statement_cache_type (
+      pgsql::connection& c,
+      image_type&,
+      id_image_type&,
+      pgsql::binding& id,
+      pgsql::binding&,
+      pgsql::native_binding& idn,
+      const unsigned int* idt)
+    : tests (c, id, idn, idt),
+      builds (c, id, idn, idt),
+      constraints (c, id, idn, idt)
+    {
+    }
+  };
+
+  // tests
+  //
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  select_name[] = "select_brep_build_package_tests";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  insert_name[] = "insert_brep_build_package_tests";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  delete_name[] = "delete_brep_build_package_tests";
+
+  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  select_statement[] =
+  "SELECT "
+  "\"build_package_tests\".\"index\", "
+  "\"build_package_tests\".\"test_name\"::TEXT, "
+  "\"build_package_tests\".\"test_package_tenant\", "
+  "\"build_package_tests\".\"test_package_name\"::TEXT, "
+  "\"build_package_tests\".\"test_package_version_epoch\", "
+  "\"build_package_tests\".\"test_package_version_canonical_upstream\", "
+  "\"build_package_tests\".\"test_package_version_canonical_release\", "
+  "\"build_package_tests\".\"test_package_version_revision\" "
+  "FROM \"build_package_tests\" "
+  "WHERE \"build_package_tests\".\"tenant\"=$1 AND \"build_package_tests\".\"name\"=$2::CITEXT AND \"build_package_tests\".\"version_epoch\"=$3 AND \"build_package_tests\".\"version_canonical_upstream\"=$4 AND \"build_package_tests\".\"version_canonical_release\"=$5 AND \"build_package_tests\".\"version_revision\"=$6 ORDER BY \"build_package_tests\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  insert_statement[] =
+  "INSERT INTO \"build_package_tests\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"test_name\", "
+  "\"test_package_tenant\", "
+  "\"test_package_name\", "
+  "\"test_package_version_epoch\", "
+  "\"test_package_version_canonical_upstream\", "
+  "\"test_package_version_canonical_release\", "
+  "\"test_package_version_revision\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8::CITEXT, $9, $10::CITEXT, $11, $12, $13, $14)";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  delete_statement[] =
+  "DELETE FROM \"build_package_tests\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // builds
+  //
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  select_name[] = "select_brep_build_package_builds";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  insert_name[] = "insert_brep_build_package_builds";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  delete_name[] = "delete_brep_build_package_builds";
+
+  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  select_statement[] =
+  "SELECT "
+  "\"build_package_builds\".\"index\", "
+  "\"build_package_builds\".\"expression\", "
+  "\"build_package_builds\".\"comment\" "
+  "FROM \"build_package_builds\" "
+  "WHERE \"build_package_builds\".\"tenant\"=$1 AND \"build_package_builds\".\"name\"=$2::CITEXT AND \"build_package_builds\".\"version_epoch\"=$3 AND \"build_package_builds\".\"version_canonical_upstream\"=$4 AND \"build_package_builds\".\"version_canonical_release\"=$5 AND \"build_package_builds\".\"version_revision\"=$6 ORDER BY \"build_package_builds\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  insert_statement[] =
+  "INSERT INTO \"build_package_builds\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"expression\", "
+  "\"comment\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  delete_statement[] =
+  "DELETE FROM \"build_package_builds\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // constraints
+  //
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  select_name[] = "select_brep_build_package_constraints";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  insert_name[] = "insert_brep_build_package_constraints";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  delete_name[] = "delete_brep_build_package_constraints";
+
+  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  select_statement[] =
+  "SELECT "
+  "\"build_package_constraints\".\"index\", "
+  "\"build_package_constraints\".\"exclusion\", "
+  "\"build_package_constraints\".\"config\", "
+  "\"build_package_constraints\".\"target\", "
+  "\"build_package_constraints\".\"comment\" "
+  "FROM \"build_package_constraints\" "
+  "WHERE \"build_package_constraints\".\"tenant\"=$1 AND \"build_package_constraints\".\"name\"=$2::CITEXT AND \"build_package_constraints\".\"version_epoch\"=$3 AND \"build_package_constraints\".\"version_canonical_upstream\"=$4 AND \"build_package_constraints\".\"version_canonical_release\"=$5 AND \"build_package_constraints\".\"version_revision\"=$6 ORDER BY \"build_package_constraints\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  insert_statement[] =
+  "INSERT INTO \"build_package_constraints\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"exclusion\", "
+  "\"config\", "
+  "\"target\", "
+  "\"comment\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11)";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  delete_statement[] =
+  "DELETE FROM \"build_package_constraints\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  access::object_traits_impl< ::brep::build_package, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        id,
+        i.id_value,
+        db);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // version
+    //
+    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
+          i.version_value, t + 6UL))
+      grew = true;
+
+    // internal_repository
+    //
+    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
+          i.internal_repository_value, t + 8UL))
+      grew = true;
+
+    // buildable
+    //
+    t[10UL] = 0;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    assert (sk != statement_update);
+
+    std::size_t n (0);
+
+    // id
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+    n += 6UL;
+
+    // version
+    //
+    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
+      b + n, i.version_value, sk);
+    n += 2UL;
+
+    // internal_repository
+    //
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, i.internal_repository_value, sk);
+    n += 2UL;
+
+    // buildable
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.buildable_value;
+    b[n].is_null = &i.buildable_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    assert (sk != statement_update);
+
+    bool grew (false);
+
+    // id
+    //
+    {
+      ::brep::package_id const& v =
+        o.id;
+
+      if (composite_value_traits< ::brep::package_id, id_pgsql >::init (
+            i.id_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // version
+    //
+    {
+      ::brep::upstream_version const& v =
+        o.version;
+
+      if (composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+            i.version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // internal_repository
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::build_repository > const& v =
+        o.internal_repository;
+
+      typedef object_traits< ::brep::build_repository > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_repository > > ptr_traits;
+
+      bool is_null (ptr_traits::null_ptr (v));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (v));
+
+        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+              i.internal_repository_value,
+              ptr_id,
+              sk))
+          grew = true;
+      }
+      else
+        composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.internal_repository_value, sk);
+    }
+
+    // buildable
+    //
+    {
+      bool const& v =
+        o.buildable;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.buildable_value, is_null, v);
+      i.buildable_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::package_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // version
+    //
+    {
+      // From build-package.hxx:117:32
+      ::brep::upstream_version v;
+
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+        v,
+        i.version_value,
+        db);
+
+      // From build-package.hxx:117:32
+      o.version.init (o.id.version, (v));
+    }
+
+    // internal_repository
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::build_repository >& v =
+        o.internal_repository;
+
+      typedef object_traits< ::brep::build_repository > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_repository > > ptr_traits;
+
+      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
+            i.internal_repository_value))
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+          ptr_id,
+          i.internal_repository_value,
+          db);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<pgsql::database*> (db), ptr_id);
+      }
+    }
+
+    // buildable
+    //
+    {
+      bool& v =
+        o.buildable;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.buildable_value,
+        i.buildable_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    {
+      if (composite_value_traits< ::brep::package_id, id_pgsql >::init (
+            i.id_value,
+            id,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"build_package\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_upstream\", "
+  "\"version_release\", "
+  "\"internal_repository_tenant\", "
+  "\"internal_repository_canonical_name\", "
+  "\"buildable\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11)";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"build_package\".\"tenant\", "
+  "\"build_package\".\"name\"::TEXT, "
+  "\"build_package\".\"version_epoch\", "
+  "\"build_package\".\"version_canonical_upstream\", "
+  "\"build_package\".\"version_canonical_release\", "
+  "\"build_package\".\"version_revision\", "
+  "\"build_package\".\"version_upstream\", "
+  "\"build_package\".\"version_release\", "
+  "\"build_package\".\"internal_repository_tenant\", "
+  "\"build_package\".\"internal_repository_canonical_name\", "
+  "\"build_package\".\"buildable\" "
+  "FROM \"build_package\" "
+  "WHERE \"build_package\".\"tenant\"=$1 AND \"build_package\".\"name\"=$2::CITEXT AND \"build_package\".\"version_epoch\"=$3 AND \"build_package\".\"version_canonical_upstream\"=$4 AND \"build_package\".\"version_canonical_release\"=$5 AND \"build_package\".\"version_revision\"=$6";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"build_package\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::query_statement[] =
+  "SELECT\n"
+  "\"build_package\".\"tenant\",\n"
+  "\"build_package\".\"name\"::TEXT,\n"
+  "\"build_package\".\"version_epoch\",\n"
+  "\"build_package\".\"version_canonical_upstream\",\n"
+  "\"build_package\".\"version_canonical_release\",\n"
+  "\"build_package\".\"version_revision\",\n"
+  "\"build_package\".\"version_upstream\",\n"
+  "\"build_package\".\"version_release\",\n"
+  "\"build_package\".\"internal_repository_tenant\",\n"
+  "\"build_package\".\"internal_repository_canonical_name\",\n"
+  "\"build_package\".\"buildable\"\n"
+  "FROM \"build_package\"\n"
+  "LEFT JOIN \"build_repository\" AS \"internal_repository\" ON \"internal_repository\".\"tenant\"=\"build_package\".\"internal_repository_tenant\" AND \"internal_repository\".\"canonical_name\"=\"build_package\".\"internal_repository_canonical_name\"";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"build_package\"";
+
+  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::table_name[] =
+  "\"build_package\"";
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::brep::build_test_dependency, 1 > const& v =
+        obj.tests;
+
+      tests_traits::persist (
+        v,
+        esc.tests);
+    }
+
+    // builds
+    //
+    {
+      ::brep::build_class_exprs const& v =
+        obj.builds;
+
+      builds_traits::persist (
+        v,
+        esc.builds);
+    }
+
+    // constraints
+    //
+    {
+      ::brep::build_constraints const& v =
+        obj.constraints;
+
+      constraints_traits::persist (
+        v,
+        esc.constraints);
+    }
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // tests
+    //
+    {
+      tests_traits::erase (
+        esc.tests);
+    }
+
+    // builds
+    //
+    {
+      builds_traits::erase (
+        esc.builds);
+    }
+
+    // constraints
+    //
+    {
+      constraints_traits::erase (
+        esc.constraints);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::build_package, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::brep::build_test_dependency, 1 >& v =
+        obj.tests;
+
+      tests_traits::load (
+        v,
+        esc.tests);
+    }
+
+    // builds
+    //
+    {
+      ::brep::build_class_exprs& v =
+        obj.builds;
+
+      builds_traits::load (
+        v,
+        esc.builds);
+    }
+
+    // constraints
+    //
+    {
+      ::brep::build_constraints& v =
+        obj.constraints;
+
+      constraints_traits::load (
+        v,
+        esc.constraints);
+    }
+  }
+
+  result< access::object_traits_impl< ::brep::build_package, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += "\n";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        true,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += "\n";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        true,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // buildable_package
+  //
+
+  const char access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  query_statement_name[] = "query_brep_buildable_package";
+
+  bool access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // version
+    //
+    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
+          i.version_value, t + 6UL))
+      grew = true;
+
+    // archived
+    //
+    t[8UL] = 0;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // id
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+    n += 6UL;
+
+    // version
+    //
+    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
+      b + n, i.version_value, sk);
+    n += 2UL;
+
+    // archived
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.archived_value;
+    b[n].is_null = &i.archived_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::package_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // version
+    //
+    {
+      // From build-package.hxx:148:32
+      ::brep::upstream_version v;
+
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
+        v,
+        i.version_value,
+        db);
+
+      // From build-package.hxx:148:32
+      o.version.init (o.id.version, (v));
+    }
+
+    // archived
+    //
+    {
+      bool& v =
+        o.archived;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.archived_value,
+        i.archived_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"build_package\".\"tenant\", "
+      "\"build_package\".\"name\"::TEXT, "
+      "\"build_package\".\"version_epoch\", "
+      "\"build_package\".\"version_canonical_upstream\", "
+      "\"build_package\".\"version_canonical_release\", "
+      "\"build_package\".\"version_revision\", "
+      "\"build_package\".\"version_upstream\", "
+      "\"build_package\".\"version_release\", "
+      "\"build_tenant\".\"archived\" ");
+
+    r += "FROM \"build_package\"";
+
+    r += " INNER JOIN \"build_repository\" ON";
+    // From build-package.hxx:134:5
+    r += query_columns::build_package::buildable && brep::operator == (query_columns::build_package::internal_repository, query_columns::build_repository::id);
+
+    r += " LEFT JOIN \"build_tenant\" ON";
+    // From build-package.hxx:138:5
+    r += query_columns::build_package::id.tenant == query_columns::build_tenant::id;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::buildable_package, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // buildable_package_count
+  //
+
+  const char access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  query_statement_name[] = "query_brep_buildable_package_count";
+
+  bool access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = 0;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      pgsql::value_traits<
+          ::std::size_t,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "count(\"build_package\".\"name\") ");
+
+    r += "FROM \"build_package\"";
+
+    r += " INNER JOIN \"build_repository\" ON";
+    // From build-package.hxx:153:5
+    r += query_columns::build_package::buildable && brep::operator == (query_columns::build_package::internal_repository, query_columns::build_repository::id);
+
+    r += " LEFT JOIN \"build_tenant\" ON";
+    // From build-package.hxx:157:5
+    r += query_columns::build_package::id.tenant == query_columns::build_tenant::id;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+}
+
+#include <odb/post.hxx>
diff --git a/libbrep/build-package-odb.hxx b/libbrep/build-package-odb.hxx
new file mode 100644
index 0000000..a0694e1
--- /dev/null
+++ b/libbrep/build-package-odb.hxx
@@ -0,0 +1,1877 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#ifndef LIBBREP_BUILD_PACKAGE_ODB_HXX
+#define LIBBREP_BUILD_PACKAGE_ODB_HXX
+
+#include <odb/version.hxx>
+
+#if (ODB_VERSION != 20470UL)
+#error ODB runtime version mismatch
+#endif
+
+#include <odb/pre.hxx>
+
+#include <libbrep/build-package.hxx>
+
+#include <libbrep/common-odb.hxx>
+
+#include <memory>
+#include <cstddef>
+#include <utility>
+
+#include <odb/core.hxx>
+#include <odb/traits.hxx>
+#include <odb/callback.hxx>
+#include <odb/wrapper-traits.hxx>
+#include <odb/pointer-traits.hxx>
+#include <odb/container-traits.hxx>
+#include <odb/session.hxx>
+#include <odb/cache-traits.hxx>
+#include <odb/prepared-query.hxx>
+#include <odb/result.hxx>
+#include <odb/simple-object-result.hxx>
+#include <odb/view-image.hxx>
+#include <odb/view-result.hxx>
+
+#include <odb/details/unused.hxx>
+#include <odb/details/shared-ptr.hxx>
+
+namespace odb
+{
+  // build_tenant
+  //
+  template <>
+  struct class_traits< ::brep::build_tenant >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::build_tenant >
+  {
+    public:
+    typedef ::brep::build_tenant object_type;
+    typedef ::std::shared_ptr< ::brep::build_tenant > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::std::string id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    no_op_pointer_cache_traits<pointer_type>
+    pointer_cache_traits;
+
+    typedef
+    no_op_reference_cache_traits<object_type>
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // build_repository
+  //
+  template <>
+  struct class_traits< ::brep::build_repository >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::build_repository >
+  {
+    public:
+    typedef ::brep::build_repository object_type;
+    typedef ::std::shared_ptr< ::brep::build_repository > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::brep::repository_id id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    no_op_pointer_cache_traits<pointer_type>
+    pointer_cache_traits;
+
+    typedef
+    no_op_reference_cache_traits<object_type>
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // build_package
+  //
+  template <>
+  struct class_traits< ::brep::build_package >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::build_package >
+  {
+    public:
+    typedef ::brep::build_package object_type;
+    typedef ::std::shared_ptr< ::brep::build_package > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::brep::package_id id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // buildable_package
+  //
+  template <>
+  struct class_traits< ::brep::buildable_package >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::buildable_package >
+  {
+    public:
+    typedef ::brep::buildable_package view_type;
+    typedef ::brep::buildable_package* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // buildable_package_count
+  //
+  template <>
+  struct class_traits< ::brep::buildable_package_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::buildable_package_count >
+  {
+    public:
+    typedef ::brep::buildable_package_count view_type;
+    typedef ::brep::buildable_package_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+}
+
+#include <odb/details/buffer.hxx>
+
+#include <odb/pgsql/version.hxx>
+#include <odb/pgsql/forward.hxx>
+#include <odb/pgsql/binding.hxx>
+#include <odb/pgsql/pgsql-types.hxx>
+#include <odb/pgsql/query.hxx>
+
+namespace odb
+{
+  // build_tenant
+  //
+  template <typename A>
+  struct query_columns< ::brep::build_tenant, id_pgsql, A >
+  {
+    // id
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    id_type_;
+
+    static const id_type_ id;
+
+    // archived
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    archived_type_;
+
+    static const archived_type_ archived;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::build_tenant, id_pgsql, A >::id_type_
+  query_columns< ::brep::build_tenant, id_pgsql, A >::
+  id (A::table_name, "\"id\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_tenant, id_pgsql, A >::archived_type_
+  query_columns< ::brep::build_tenant, id_pgsql, A >::
+  archived (A::table_name, "\"archived\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::brep::build_tenant, id_pgsql, A >:
+    query_columns< ::brep::build_tenant, id_pgsql, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build_tenant, id_pgsql >:
+    public access::object_traits< ::brep::build_tenant >
+  {
+    public:
+    struct id_image_type
+    {
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      // archived
+      //
+      bool archived_value;
+      bool archived_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 2UL;
+    static const std::size_t id_column_count = 1UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 1UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build_tenant, id_common >:
+    public access::object_traits_impl< ::brep::build_tenant, id_pgsql >
+  {
+  };
+
+  // build_repository
+  //
+  template <typename A>
+  struct query_columns< ::brep::build_repository, id_pgsql, A >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // canonical_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      canonical_name_type_;
+
+      static const canonical_name_type_ canonical_name;
+    };
+
+    static const id_class_ id;
+
+    // location
+    //
+    struct location_class_
+    {
+      location_class_ ()
+      {
+      }
+
+      // url
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      url_type_;
+
+      static const url_type_ url;
+
+      // type
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      type_type_;
+
+      static const type_type_ type;
+    };
+
+    static const location_class_ location;
+
+    // certificate_fingerprint
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    certificate_fingerprint_type_;
+
+    static const certificate_fingerprint_type_ certificate_fingerprint;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::build_repository, id_pgsql, A >::id_class_::tenant_type_
+  query_columns< ::brep::build_repository, id_pgsql, A >::id_class_::
+  tenant (A::table_name, "\"tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_repository, id_pgsql, A >::id_class_::canonical_name_type_
+  query_columns< ::brep::build_repository, id_pgsql, A >::id_class_::
+  canonical_name (A::table_name, "\"canonical_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_repository, id_pgsql, A >::id_class_
+  query_columns< ::brep::build_repository, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_repository, id_pgsql, A >::location_class_::url_type_
+  query_columns< ::brep::build_repository, id_pgsql, A >::location_class_::
+  url (A::table_name, "\"location_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_repository, id_pgsql, A >::location_class_::type_type_
+  query_columns< ::brep::build_repository, id_pgsql, A >::location_class_::
+  type (A::table_name, "\"location_type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_repository, id_pgsql, A >::location_class_
+  query_columns< ::brep::build_repository, id_pgsql, A >::location;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_repository, id_pgsql, A >::certificate_fingerprint_type_
+  query_columns< ::brep::build_repository, id_pgsql, A >::
+  certificate_fingerprint (A::table_name, "\"certificate_fingerprint\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::brep::build_repository, id_pgsql, A >:
+    query_columns< ::brep::build_repository, id_pgsql, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build_repository, id_pgsql >:
+    public access::object_traits< ::brep::build_repository >
+  {
+    public:
+    struct id_image_type
+    {
+      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type id_value;
+
+      // location
+      //
+      composite_value_traits< ::brep::_repository_location, id_pgsql >::image_type location_value;
+
+      // certificate_fingerprint
+      //
+      details::buffer certificate_fingerprint_value;
+      std::size_t certificate_fingerprint_size;
+      bool certificate_fingerprint_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 5UL;
+    static const std::size_t id_column_count = 2UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 3UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build_repository, id_common >:
+    public access::object_traits_impl< ::brep::build_repository, id_pgsql >
+  {
+  };
+
+  // build_test_dependency
+  //
+  template <>
+  class access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >
+  {
+    public:
+    typedef ::brep::build_test_dependency value_type;
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // package
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type package_value;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 7UL;
+  };
+
+  // build_package
+  //
+  template <typename A>
+  struct pointer_query_columns< ::brep::build_package, id_pgsql, A >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      name_type_;
+
+      static const name_type_ name;
+
+      // version
+      //
+      struct version_class_1_
+      {
+        version_class_1_ ()
+        {
+        }
+
+        // epoch
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        epoch_type_;
+
+        static const epoch_type_ epoch;
+
+        // canonical_upstream
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_upstream_type_;
+
+        static const canonical_upstream_type_ canonical_upstream;
+
+        // canonical_release
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_release_type_;
+
+        static const canonical_release_type_ canonical_release;
+
+        // revision
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        revision_type_;
+
+        static const revision_type_ revision;
+      };
+
+      static const version_class_1_ version;
+    };
+
+    static const id_class_ id;
+
+    // version
+    //
+    struct version_class_
+    {
+      version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const version_class_ version;
+
+    // internal_repository
+    //
+    struct internal_repository_class_
+    {
+      internal_repository_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // canonical_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      canonical_name_type_;
+
+      static const canonical_name_type_ canonical_name;
+    };
+
+    static const internal_repository_class_ internal_repository;
+
+    // buildable
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    buildable_type_;
+
+    static const buildable_type_ buildable;
+  };
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::tenant_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::
+  tenant (A::table_name, "\"tenant\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::name_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::
+  name (A::table_name, "\"name\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::epoch_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  epoch (A::table_name, "\"version_epoch\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::canonical_upstream_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::canonical_release_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_release (A::table_name, "\"version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::revision_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  revision (A::table_name, "\"version_revision\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::id_class_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::version_class_::upstream_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::version_class_::
+  upstream (A::table_name, "\"version_upstream\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::version_class_::release_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::version_class_::
+  release (A::table_name, "\"version_release\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::version_class_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::version;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_class_::tenant_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_class_::
+  tenant (A::table_name, "\"internal_repository_tenant\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_class_::canonical_name_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_class_::
+  canonical_name (A::table_name, "\"internal_repository_canonical_name\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_class_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::internal_repository;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::build_package, id_pgsql, A >::buildable_type_
+  pointer_query_columns< ::brep::build_package, id_pgsql, A >::
+  buildable (A::table_name, "\"buildable\"", 0);
+
+  template <>
+  class access::object_traits_impl< ::brep::build_package, id_pgsql >:
+    public access::object_traits< ::brep::build_package >
+  {
+    public:
+    struct id_image_type
+    {
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      // version
+      //
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::image_type version_value;
+
+      // internal_repository
+      //
+      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type internal_repository_value;
+
+      // buildable
+      //
+      bool buildable_value;
+      bool buildable_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // tests
+    //
+    struct tests_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 14UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::butl::small_vector< ::brep::build_test_dependency, 1 > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< tests_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // builds
+    //
+    struct builds_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::brep::build_class_exprs container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< builds_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // constraints
+    //
+    struct constraints_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 11UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::brep::build_constraints container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< constraints_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    struct internal_repository_tag;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 11UL;
+    static const std::size_t id_column_count = 6UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 5UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::build_package, id_common >:
+    public access::object_traits_impl< ::brep::build_package, id_pgsql >
+  {
+  };
+
+  // buildable_package
+  //
+  template <>
+  class access::view_traits_impl< ::brep::buildable_package, id_pgsql >:
+    public access::view_traits< ::brep::buildable_package >
+  {
+    public:
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      // version
+      //
+      composite_value_traits< ::brep::upstream_version, id_pgsql >::image_type version_value;
+
+      // archived
+      //
+      bool archived_value;
+      bool archived_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 9UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::buildable_package, id_common >:
+    public access::view_traits_impl< ::brep::buildable_package, id_pgsql >
+  {
+  };
+
+  // buildable_package_count
+  //
+  template <>
+  class access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >:
+    public access::view_traits< ::brep::buildable_package_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::buildable_package_count, id_common >:
+    public access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >
+  {
+  };
+
+  // build_tenant
+  //
+  // build_repository
+  //
+  // build_package
+  //
+  template <>
+  struct alias_traits<
+    ::brep::build_repository,
+    id_pgsql,
+    access::object_traits_impl< ::brep::build_package, id_pgsql >::internal_repository_tag>
+  {
+    static const char table_name[];
+  };
+
+  template <>
+  struct query_columns_base< ::brep::build_package, id_pgsql >
+  {
+    // internal_repository
+    //
+    typedef
+    odb::alias_traits<
+      ::brep::build_repository,
+      id_pgsql,
+      access::object_traits_impl< ::brep::build_package, id_pgsql >::internal_repository_tag>
+    internal_repository_alias_;
+  };
+
+  template <typename A>
+  struct query_columns< ::brep::build_package, id_pgsql, A >:
+    query_columns_base< ::brep::build_package, id_pgsql >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      name_type_;
+
+      static const name_type_ name;
+
+      // version
+      //
+      struct version_class_1_
+      {
+        version_class_1_ ()
+        {
+        }
+
+        // epoch
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        epoch_type_;
+
+        static const epoch_type_ epoch;
+
+        // canonical_upstream
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_upstream_type_;
+
+        static const canonical_upstream_type_ canonical_upstream;
+
+        // canonical_release
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_release_type_;
+
+        static const canonical_release_type_ canonical_release;
+
+        // revision
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        revision_type_;
+
+        static const revision_type_ revision;
+      };
+
+      static const version_class_1_ version;
+    };
+
+    static const id_class_ id;
+
+    // version
+    //
+    struct version_class_
+    {
+      version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const version_class_ version;
+
+    // internal_repository
+    //
+    struct internal_repository_column_class_
+    {
+      internal_repository_column_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // canonical_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      canonical_name_type_;
+
+      static const canonical_name_type_ canonical_name;
+    };
+
+    typedef
+    odb::query_pointer<
+      odb::pointer_query_columns<
+        ::brep::build_repository,
+        id_pgsql,
+        internal_repository_alias_ > >
+    internal_repository_pointer_type_;
+
+    struct internal_repository_type_: internal_repository_pointer_type_, internal_repository_column_class_
+    {
+      internal_repository_type_ ()
+      {
+      }
+    };
+
+    static const internal_repository_type_ internal_repository;
+
+    // buildable
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    buildable_type_;
+
+    static const buildable_type_ buildable;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_::tenant_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::id_class_::
+  tenant (A::table_name, "\"tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_::name_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::id_class_::
+  name (A::table_name, "\"name\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::epoch_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  epoch (A::table_name, "\"version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::canonical_upstream_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::canonical_release_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_release (A::table_name, "\"version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::revision_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_::
+  revision (A::table_name, "\"version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version_class_1_
+  query_columns< ::brep::build_package, id_pgsql, A >::id_class_::version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::id_class_
+  query_columns< ::brep::build_package, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::version_class_::upstream_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::version_class_::
+  upstream (A::table_name, "\"version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::version_class_::release_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::version_class_::
+  release (A::table_name, "\"version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::version_class_
+  query_columns< ::brep::build_package, id_pgsql, A >::version;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_column_class_::tenant_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_column_class_::
+  tenant (A::table_name, "\"internal_repository_tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_column_class_::canonical_name_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_column_class_::
+  canonical_name (A::table_name, "\"internal_repository_canonical_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::internal_repository_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::internal_repository;
+
+  template <typename A>
+  const typename query_columns< ::brep::build_package, id_pgsql, A >::buildable_type_
+  query_columns< ::brep::build_package, id_pgsql, A >::
+  buildable (A::table_name, "\"buildable\"", 0);
+
+  // buildable_package
+  //
+  struct access::view_traits_impl< ::brep::buildable_package, id_pgsql >::query_columns
+  {
+    // build_package
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_package,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_package, id_pgsql > >
+    build_package;
+
+    // build_repository
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_repository,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_repository, id_pgsql > >
+    build_repository;
+
+    // build_tenant
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_tenant,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_tenant, id_pgsql > >
+    build_tenant;
+  };
+
+  // buildable_package_count
+  //
+  struct access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::query_columns
+  {
+    // build_package
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_package,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_package, id_pgsql > >
+    build_package;
+
+    // build_repository
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_repository,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_repository, id_pgsql > >
+    build_repository;
+
+    // build_tenant
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::brep::build_tenant,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::build_tenant, id_pgsql > >
+    build_tenant;
+  };
+}
+
+#include <libbrep/build-package-odb.ixx>
+
+#include <odb/post.hxx>
+
+#endif // LIBBREP_BUILD_PACKAGE_ODB_HXX
diff --git a/libbrep/build-package-odb.ixx b/libbrep/build-package-odb.ixx
new file mode 100644
index 0000000..b2c2f40
--- /dev/null
+++ b/libbrep/build-package-odb.ixx
@@ -0,0 +1,211 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+namespace odb
+{
+  // build_tenant
+  //
+
+  inline
+  access::object_traits< ::brep::build_tenant >::id_type
+  access::object_traits< ::brep::build_tenant >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::build_tenant >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::build_tenant >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // build_repository
+  //
+
+  inline
+  access::object_traits< ::brep::build_repository >::id_type
+  access::object_traits< ::brep::build_repository >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::build_repository >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::build_repository >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // build_package
+  //
+
+  inline
+  access::object_traits< ::brep::build_package >::id_type
+  access::object_traits< ::brep::build_package >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::build_package >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::build_package >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // buildable_package
+  //
+
+  inline
+  void access::view_traits< ::brep::buildable_package >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // buildable_package_count
+  //
+
+  inline
+  void access::view_traits< ::brep::buildable_package_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+}
+
+namespace odb
+{
+  // build_tenant
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  inline
+  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool)
+  {
+    ODB_POTENTIALLY_UNUSED (sts);
+    ODB_POTENTIALLY_UNUSED (obj);
+  }
+
+  // build_repository
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  inline
+  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool)
+  {
+    ODB_POTENTIALLY_UNUSED (sts);
+    ODB_POTENTIALLY_UNUSED (obj);
+  }
+
+  // build_test_dependency
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.name_null;
+    r = r && composite_value_traits< ::brep::package_id, id_pgsql >::get_null (i.package_value);
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.name_null = true;
+    composite_value_traits< ::brep::package_id, id_pgsql >::set_null (i.package_value, sk);
+  }
+
+  // build_package
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // buildable_package
+  //
+
+  // buildable_package_count
+  //
+}
+
diff --git a/libbrep/build.sql b/libbrep/build.sql
new file mode 100644
index 0000000..2d62823
--- /dev/null
+++ b/libbrep/build.sql
@@ -0,0 +1,158 @@
+/* This file was generated by ODB, object-relational mapping (ORM)
+ * compiler for C++.
+ */
+
+DROP TABLE IF EXISTS "build_delay" CASCADE;
+
+DROP TABLE IF EXISTS "build_results" CASCADE;
+
+DROP TABLE IF EXISTS "build" CASCADE;
+
+DROP TABLE IF EXISTS "schema_version";
+
+CREATE TABLE "build" (
+  "package_tenant" TEXT NOT NULL,
+  "package_name" CITEXT NOT NULL,
+  "package_version_epoch" INTEGER NOT NULL,
+  "package_version_canonical_upstream" TEXT NOT NULL,
+  "package_version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "package_version_revision" INTEGER NOT NULL,
+  "configuration" TEXT NOT NULL,
+  "toolchain_name" TEXT NOT NULL,
+  "toolchain_version_epoch" INTEGER NOT NULL,
+  "toolchain_version_canonical_upstream" TEXT NOT NULL,
+  "toolchain_version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "toolchain_version_revision" INTEGER NOT NULL,
+  "package_version_upstream" TEXT NOT NULL,
+  "package_version_release" TEXT NULL,
+  "toolchain_version_upstream" TEXT NOT NULL,
+  "toolchain_version_release" TEXT NULL,
+  "state" TEXT NOT NULL,
+  "timestamp" BIGINT NOT NULL,
+  "force" TEXT NOT NULL,
+  "status" TEXT NULL,
+  "completion_timestamp" BIGINT NOT NULL DEFAULT 0,
+  "agent_fingerprint" TEXT NULL,
+  "agent_challenge" TEXT NULL,
+  "machine" TEXT NOT NULL,
+  "machine_summary" TEXT NOT NULL,
+  "target" TEXT NOT NULL,
+  PRIMARY KEY ("package_tenant",
+               "package_name",
+               "package_version_epoch",
+               "package_version_canonical_upstream",
+               "package_version_canonical_release",
+               "package_version_revision",
+               "configuration",
+               "toolchain_name",
+               "toolchain_version_epoch",
+               "toolchain_version_canonical_upstream",
+               "toolchain_version_canonical_release",
+               "toolchain_version_revision"));
+
+CREATE INDEX "build_timestamp_i"
+  ON "build" ("timestamp");
+
+CREATE TABLE "build_results" (
+  "package_tenant" TEXT NOT NULL,
+  "package_name" CITEXT NOT NULL,
+  "package_version_epoch" INTEGER NOT NULL,
+  "package_version_canonical_upstream" TEXT NOT NULL,
+  "package_version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "package_version_revision" INTEGER NOT NULL,
+  "configuration" TEXT NOT NULL,
+  "toolchain_name" TEXT NOT NULL,
+  "toolchain_version_epoch" INTEGER NOT NULL,
+  "toolchain_version_canonical_upstream" TEXT NOT NULL,
+  "toolchain_version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "toolchain_version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "operation" TEXT NOT NULL,
+  "status" TEXT NOT NULL,
+  "log" TEXT NOT NULL,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("package_tenant",
+                 "package_name",
+                 "package_version_epoch",
+                 "package_version_canonical_upstream",
+                 "package_version_canonical_release",
+                 "package_version_revision",
+                 "configuration",
+                 "toolchain_name",
+                 "toolchain_version_epoch",
+                 "toolchain_version_canonical_upstream",
+                 "toolchain_version_canonical_release",
+                 "toolchain_version_revision")
+    REFERENCES "build" ("package_tenant",
+                        "package_name",
+                        "package_version_epoch",
+                        "package_version_canonical_upstream",
+                        "package_version_canonical_release",
+                        "package_version_revision",
+                        "configuration",
+                        "toolchain_name",
+                        "toolchain_version_epoch",
+                        "toolchain_version_canonical_upstream",
+                        "toolchain_version_canonical_release",
+                        "toolchain_version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "build_results_object_id_i"
+  ON "build_results" (
+    "package_tenant",
+    "package_name",
+    "package_version_epoch",
+    "package_version_canonical_upstream",
+    "package_version_canonical_release",
+    "package_version_revision",
+    "configuration",
+    "toolchain_name",
+    "toolchain_version_epoch",
+    "toolchain_version_canonical_upstream",
+    "toolchain_version_canonical_release",
+    "toolchain_version_revision");
+
+CREATE INDEX "build_results_index_i"
+  ON "build_results" ("index");
+
+CREATE TABLE "build_delay" (
+  "package_tenant" TEXT NOT NULL,
+  "package_name" CITEXT NOT NULL,
+  "package_version_epoch" INTEGER NOT NULL,
+  "package_version_canonical_upstream" TEXT NOT NULL,
+  "package_version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "package_version_revision" INTEGER NOT NULL,
+  "configuration" TEXT NOT NULL,
+  "toolchain_name" TEXT NOT NULL,
+  "toolchain_version_epoch" INTEGER NOT NULL,
+  "toolchain_version_canonical_upstream" TEXT NOT NULL,
+  "toolchain_version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "toolchain_version_revision" INTEGER NOT NULL,
+  "package_version_upstream" TEXT NOT NULL,
+  "package_version_release" TEXT NULL,
+  "toolchain_version_upstream" TEXT NOT NULL,
+  "toolchain_version_release" TEXT NULL,
+  "report_timestamp" BIGINT NOT NULL,
+  "package_timestamp" BIGINT NOT NULL,
+  PRIMARY KEY ("package_tenant",
+               "package_name",
+               "package_version_epoch",
+               "package_version_canonical_upstream",
+               "package_version_canonical_release",
+               "package_version_revision",
+               "configuration",
+               "toolchain_name",
+               "toolchain_version_epoch",
+               "toolchain_version_canonical_upstream",
+               "toolchain_version_canonical_release",
+               "toolchain_version_revision"));
+
+CREATE TABLE "schema_version" (
+  "name" TEXT NOT NULL PRIMARY KEY,
+  "version" BIGINT NOT NULL,
+  "migration" BOOLEAN NOT NULL);
+
+INSERT INTO "schema_version" (
+  "name", "version", "migration")
+  VALUES ('build', 12, FALSE);
+
diff --git a/libbrep/common-odb.cxx b/libbrep/common-odb.cxx
new file mode 100644
index 0000000..261b29b
--- /dev/null
+++ b/libbrep/common-odb.cxx
@@ -0,0 +1,1744 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#include <odb/pre.hxx>
+
+#include <libbrep/common-odb.hxx>
+
+#include <cassert>
+#include <cstring>  // std::memcpy
+
+
+#include <odb/pgsql/traits.hxx>
+#include <odb/pgsql/database.hxx>
+#include <odb/pgsql/transaction.hxx>
+#include <odb/pgsql/connection.hxx>
+#include <odb/pgsql/statement.hxx>
+#include <odb/pgsql/statement-cache.hxx>
+#include <odb/pgsql/container-statements.hxx>
+#include <odb/pgsql/exceptions.hxx>
+
+namespace odb
+{
+  // _version
+  //
+
+  bool access::composite_value_traits< ::brep::_version, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // epoch
+    //
+    t[0UL] = 0;
+
+    // canonical_upstream
+    //
+    if (t[1UL])
+    {
+      i.canonical_upstream_value.capacity (i.canonical_upstream_size);
+      grew = true;
+    }
+
+    // canonical_release
+    //
+    if (t[2UL])
+    {
+      i.canonical_release_value.capacity (i.canonical_release_size);
+      grew = true;
+    }
+
+    // revision
+    //
+    t[3UL] = 0;
+
+    // upstream
+    //
+    if (t[4UL])
+    {
+      i.upstream_value.capacity (i.upstream_size);
+      grew = true;
+    }
+
+    // release
+    //
+    if (t[5UL])
+    {
+      i.release_value.capacity (i.release_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::_version, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // epoch
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.epoch_value;
+    b[n].is_null = &i.epoch_null;
+    n++;
+
+    // canonical_upstream
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.canonical_upstream_value.data ();
+    b[n].capacity = i.canonical_upstream_value.capacity ();
+    b[n].size = &i.canonical_upstream_size;
+    b[n].is_null = &i.canonical_upstream_null;
+    n++;
+
+    // canonical_release
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.canonical_release_value.data ();
+    b[n].capacity = i.canonical_release_value.capacity ();
+    b[n].size = &i.canonical_release_size;
+    b[n].is_null = &i.canonical_release_null;
+    n++;
+
+    // revision
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.revision_value;
+    b[n].is_null = &i.revision_null;
+    n++;
+
+    // upstream
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.upstream_value.data ();
+    b[n].capacity = i.upstream_value.capacity ();
+    b[n].size = &i.upstream_size;
+    b[n].is_null = &i.upstream_null;
+    n++;
+
+    // release
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.release_value.data ();
+    b[n].capacity = i.release_value.capacity ();
+    b[n].size = &i.release_size;
+    b[n].is_null = &i.release_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::_version, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // epoch
+    //
+    {
+      ::uint16_t const& v =
+        o.epoch;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_image (
+        i.epoch_value, is_null, v);
+      i.epoch_null = is_null;
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string const& v =
+        o.canonical_upstream;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.canonical_upstream_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.canonical_upstream_value,
+        size,
+        is_null,
+        v);
+      i.canonical_upstream_null = is_null;
+      i.canonical_upstream_size = size;
+      grew = grew || (cap != i.canonical_upstream_value.capacity ());
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string const& v =
+        o.canonical_release;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.canonical_release_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.canonical_release_value,
+        size,
+        is_null,
+        v);
+      i.canonical_release_null = is_null;
+      i.canonical_release_size = size;
+      grew = grew || (cap != i.canonical_release_value.capacity ());
+    }
+
+    // revision
+    //
+    {
+      ::butl::optional< short unsigned int > const& v =
+        o.revision;
+
+      bool is_null (true);
+      pgsql::value_traits<
+          ::butl::optional< short unsigned int >,
+          pgsql::id_integer >::set_image (
+        i.revision_value, is_null, v);
+      i.revision_null = is_null;
+    }
+
+    // upstream
+    //
+    {
+      ::std::string const& v =
+        o.upstream;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.upstream_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.upstream_value,
+        size,
+        is_null,
+        v);
+      i.upstream_null = is_null;
+      i.upstream_size = size;
+      grew = grew || (cap != i.upstream_value.capacity ());
+    }
+
+    // release
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.release;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.release_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.release_value,
+        size,
+        is_null,
+        v);
+      i.release_null = is_null;
+      i.release_size = size;
+      grew = grew || (cap != i.release_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::_version, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // epoch
+    //
+    {
+      ::uint16_t& v =
+        o.epoch;
+
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_value (
+        v,
+        i.epoch_value,
+        i.epoch_null);
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string& v =
+        o.canonical_upstream;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.canonical_upstream_value,
+        i.canonical_upstream_size,
+        i.canonical_upstream_null);
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string& v =
+        o.canonical_release;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.canonical_release_value,
+        i.canonical_release_size,
+        i.canonical_release_null);
+    }
+
+    // revision
+    //
+    {
+      ::butl::optional< short unsigned int >& v =
+        o.revision;
+
+      pgsql::value_traits<
+          ::butl::optional< short unsigned int >,
+          pgsql::id_integer >::set_value (
+        v,
+        i.revision_value,
+        i.revision_null);
+    }
+
+    // upstream
+    //
+    {
+      ::std::string& v =
+        o.upstream;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.upstream_value,
+        i.upstream_size,
+        i.upstream_null);
+    }
+
+    // release
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.release;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.release_value,
+        i.release_size,
+        i.release_null);
+    }
+  }
+
+  // build_constraint
+  //
+
+  bool access::composite_value_traits< ::bpkg::build_constraint, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // exclusion
+    //
+    t[0UL] = 0;
+
+    // config
+    //
+    if (t[1UL])
+    {
+      i.config_value.capacity (i.config_size);
+      grew = true;
+    }
+
+    // target
+    //
+    if (t[2UL])
+    {
+      i.target_value.capacity (i.target_size);
+      grew = true;
+    }
+
+    // comment
+    //
+    if (t[3UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::build_constraint, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // exclusion
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.exclusion_value;
+    b[n].is_null = &i.exclusion_null;
+    n++;
+
+    // config
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.config_value.data ();
+    b[n].capacity = i.config_value.capacity ();
+    b[n].size = &i.config_size;
+    b[n].is_null = &i.config_null;
+    n++;
+
+    // target
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.target_value.data ();
+    b[n].capacity = i.target_value.capacity ();
+    b[n].size = &i.target_size;
+    b[n].is_null = &i.target_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::build_constraint, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // exclusion
+    //
+    {
+      bool const& v =
+        o.exclusion;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.exclusion_value, is_null, v);
+      i.exclusion_null = is_null;
+    }
+
+    // config
+    //
+    {
+      ::std::string const& v =
+        o.config;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.config_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.config_value,
+        size,
+        is_null,
+        v);
+      i.config_null = is_null;
+      i.config_size = size;
+      grew = grew || (cap != i.config_value.capacity ());
+    }
+
+    // target
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.target;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.target_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.target_value,
+        size,
+        is_null,
+        v);
+      i.target_null = is_null;
+      i.target_size = size;
+      grew = grew || (cap != i.target_value.capacity ());
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::build_constraint, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // exclusion
+    //
+    {
+      bool& v =
+        o.exclusion;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.exclusion_value,
+        i.exclusion_null);
+    }
+
+    // config
+    //
+    {
+      ::std::string& v =
+        o.config;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.config_value,
+        i.config_size,
+        i.config_null);
+    }
+
+    // target
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.target;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.target_value,
+        i.target_size,
+        i.target_null);
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // build_class_expr
+  //
+
+  bool access::composite_value_traits< ::bpkg::build_class_expr, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // expression
+    //
+    if (t[0UL])
+    {
+      i.expression_value.capacity (i.expression_size);
+      grew = true;
+    }
+
+    // comment
+    //
+    if (t[1UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::build_class_expr, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // expression
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.expression_value.data ();
+    b[n].capacity = i.expression_value.capacity ();
+    b[n].size = &i.expression_size;
+    b[n].is_null = &i.expression_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::build_class_expr, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // expression
+    //
+    {
+      // From common.hxx:316:5
+      ::std::string const& v =
+        o.string ();
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.expression_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.expression_value,
+        size,
+        is_null,
+        v);
+      i.expression_null = is_null;
+      i.expression_size = size;
+      grew = grew || (cap != i.expression_value.capacity ());
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::build_class_expr, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // expression
+    //
+    {
+      // From common.hxx:317:5
+      ::std::string v;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.expression_value,
+        i.expression_size,
+        i.expression_null);
+
+      // From common.hxx:317:5
+      o = brep::build_class_expr ((v), "");
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // canonical_version
+  //
+
+  bool access::composite_value_traits< ::brep::canonical_version, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // epoch
+    //
+    t[0UL] = 0;
+
+    // canonical_upstream
+    //
+    if (t[1UL])
+    {
+      i.canonical_upstream_value.capacity (i.canonical_upstream_size);
+      grew = true;
+    }
+
+    // canonical_release
+    //
+    if (t[2UL])
+    {
+      i.canonical_release_value.capacity (i.canonical_release_size);
+      grew = true;
+    }
+
+    // revision
+    //
+    t[3UL] = 0;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::canonical_version, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // epoch
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.epoch_value;
+    b[n].is_null = &i.epoch_null;
+    n++;
+
+    // canonical_upstream
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.canonical_upstream_value.data ();
+    b[n].capacity = i.canonical_upstream_value.capacity ();
+    b[n].size = &i.canonical_upstream_size;
+    b[n].is_null = &i.canonical_upstream_null;
+    n++;
+
+    // canonical_release
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.canonical_release_value.data ();
+    b[n].capacity = i.canonical_release_value.capacity ();
+    b[n].size = &i.canonical_release_size;
+    b[n].is_null = &i.canonical_release_null;
+    n++;
+
+    // revision
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.revision_value;
+    b[n].is_null = &i.revision_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::canonical_version, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // epoch
+    //
+    {
+      ::uint16_t const& v =
+        o.epoch;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_image (
+        i.epoch_value, is_null, v);
+      i.epoch_null = is_null;
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string const& v =
+        o.canonical_upstream;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.canonical_upstream_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.canonical_upstream_value,
+        size,
+        is_null,
+        v);
+      i.canonical_upstream_null = is_null;
+      i.canonical_upstream_size = size;
+      grew = grew || (cap != i.canonical_upstream_value.capacity ());
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string const& v =
+        o.canonical_release;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.canonical_release_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.canonical_release_value,
+        size,
+        is_null,
+        v);
+      i.canonical_release_null = is_null;
+      i.canonical_release_size = size;
+      grew = grew || (cap != i.canonical_release_value.capacity ());
+    }
+
+    // revision
+    //
+    {
+      ::uint16_t const& v =
+        o.revision;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_image (
+        i.revision_value, is_null, v);
+      i.revision_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::canonical_version, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // epoch
+    //
+    {
+      ::uint16_t& v =
+        o.epoch;
+
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_value (
+        v,
+        i.epoch_value,
+        i.epoch_null);
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string& v =
+        o.canonical_upstream;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.canonical_upstream_value,
+        i.canonical_upstream_size,
+        i.canonical_upstream_null);
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string& v =
+        o.canonical_release;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.canonical_release_value,
+        i.canonical_release_size,
+        i.canonical_release_null);
+    }
+
+    // revision
+    //
+    {
+      ::uint16_t& v =
+        o.revision;
+
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_value (
+        v,
+        i.revision_value,
+        i.revision_null);
+    }
+  }
+
+  // upstream_version
+  //
+
+  bool access::composite_value_traits< ::brep::upstream_version, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // upstream_
+    //
+    if (t[0UL])
+    {
+      i.upstream_value.capacity (i.upstream_size);
+      grew = true;
+    }
+
+    // release_
+    //
+    if (t[1UL])
+    {
+      i.release_value.capacity (i.release_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::upstream_version, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // upstream_
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.upstream_value.data ();
+    b[n].capacity = i.upstream_value.capacity ();
+    b[n].size = &i.upstream_size;
+    b[n].is_null = &i.upstream_null;
+    n++;
+
+    // release_
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.release_value.data ();
+    b[n].capacity = i.release_value.capacity ();
+    b[n].size = &i.release_size;
+    b[n].is_null = &i.release_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::upstream_version, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // upstream_
+    //
+    {
+      // From common.hxx:193:7
+      ::std::string const& v =
+        o.upstream;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.upstream_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.upstream_value,
+        size,
+        is_null,
+        v);
+      i.upstream_null = is_null;
+      i.upstream_size = size;
+      grew = grew || (cap != i.upstream_value.capacity ());
+    }
+
+    // release_
+    //
+    {
+      // From common.hxx:198:7
+      ::brep::optional_string const& v =
+        o.release;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.release_value.capacity ());
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_image (
+        i.release_value,
+        size,
+        is_null,
+        v);
+      i.release_null = is_null;
+      i.release_size = size;
+      grew = grew || (cap != i.release_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::upstream_version, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // upstream_
+    //
+    {
+      // From common.hxx:194:7
+      ::std::string v;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.upstream_value,
+        i.upstream_size,
+        i.upstream_null);
+
+      // From common.hxx:194:7
+      o = brep::version (0, std::move (v), std::string (), brep::nullopt, 0);
+    }
+
+    // release_
+    //
+    {
+      // From common.hxx:199:7
+      ::brep::optional_string v;
+
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_value (
+        v,
+        i.release_value,
+        i.release_size,
+        i.release_null);
+
+      // From common.hxx:199:7
+      o = brep::version (0, std::move (o.upstream), std::move (v), brep::nullopt, 0);
+    }
+  }
+
+  // package_id
+  //
+
+  bool access::composite_value_traits< ::brep::package_id, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // tenant
+    //
+    if (t[0UL])
+    {
+      i.tenant_value.capacity (i.tenant_size);
+      grew = true;
+    }
+
+    // name
+    //
+    if (t[1UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // version
+    //
+    if (composite_value_traits< ::brep::canonical_version, id_pgsql >::grow (
+          i.version_value, t + 2UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package_id, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // tenant
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.tenant_value.data ();
+    b[n].capacity = i.tenant_value.capacity ();
+    b[n].size = &i.tenant_size;
+    b[n].is_null = &i.tenant_null;
+    n++;
+
+    // name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.name_value.data ();
+    b[n].capacity = i.name_value.capacity ();
+    b[n].size = &i.name_size;
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // version
+    //
+    composite_value_traits< ::brep::canonical_version, id_pgsql >::bind (
+      b + n, i.version_value, sk);
+    n += 4UL;
+  }
+
+  bool access::composite_value_traits< ::brep::package_id, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // tenant
+    //
+    {
+      ::std::string const& v =
+        o.tenant;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.tenant_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.tenant_value,
+        size,
+        is_null,
+        v);
+      i.tenant_null = is_null;
+      i.tenant_size = size;
+      grew = grew || (cap != i.tenant_value.capacity ());
+    }
+
+    // name
+    //
+    {
+      ::bpkg::package_name const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.name_value.capacity ());
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_image (
+        i.name_value,
+        size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      i.name_size = size;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // version
+    //
+    {
+      ::brep::canonical_version const& v =
+        o.version;
+
+      if (composite_value_traits< ::brep::canonical_version, id_pgsql >::init (
+            i.version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package_id, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // tenant
+    //
+    {
+      ::std::string& v =
+        o.tenant;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.tenant_value,
+        i.tenant_size,
+        i.tenant_null);
+    }
+
+    // name
+    //
+    {
+      ::bpkg::package_name& v =
+        o.name;
+
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // version
+    //
+    {
+      ::brep::canonical_version& v =
+        o.version;
+
+      composite_value_traits< ::brep::canonical_version, id_pgsql >::init (
+        v,
+        i.version_value,
+        db);
+    }
+  }
+
+  // _repository_location
+  //
+
+  bool access::composite_value_traits< ::brep::_repository_location, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // url
+    //
+    if (t[0UL])
+    {
+      i.url_value.capacity (i.url_size);
+      grew = true;
+    }
+
+    // type
+    //
+    if (t[1UL])
+    {
+      i.type_value.capacity (i.type_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::_repository_location, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // url
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.url_value.data ();
+    b[n].capacity = i.url_value.capacity ();
+    b[n].size = &i.url_size;
+    b[n].is_null = &i.url_null;
+    n++;
+
+    // type
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.type_value.data ();
+    b[n].capacity = i.type_value.capacity ();
+    b[n].size = &i.type_size;
+    b[n].is_null = &i.type_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::_repository_location, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // url
+    //
+    {
+      ::bpkg::repository_url const& v =
+        o.url;
+
+      // From common.hxx:268:14
+      ::std::string const& vt =
+        (v).string ();
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.url_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.url_value,
+        size,
+        is_null,
+        vt);
+      i.url_null = is_null;
+      i.url_size = size;
+      grew = grew || (cap != i.url_value.capacity ());
+    }
+
+    // type
+    //
+    {
+      ::bpkg::repository_type const& v =
+        o.type;
+
+      // From common.hxx:260:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.type_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.type_value,
+        size,
+        is_null,
+        vt);
+      i.type_null = is_null;
+      i.type_size = size;
+      grew = grew || (cap != i.type_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::_repository_location, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // url
+    //
+    {
+      ::bpkg::repository_url& v =
+        o.url;
+
+      ::std::string vt;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.url_value,
+        i.url_size,
+        i.url_null);
+
+      // From common.hxx:268:14
+      v = (vt).empty () ? brep::repository_url () : brep::repository_url (vt);
+    }
+
+    // type
+    //
+    {
+      ::bpkg::repository_type& v =
+        o.type;
+
+      ::std::string vt;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.type_value,
+        i.type_size,
+        i.type_null);
+
+      // From common.hxx:260:14
+      v = brep::to_repository_type (vt);
+    }
+  }
+
+  // repository_id
+  //
+
+  bool access::composite_value_traits< ::brep::repository_id, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // tenant
+    //
+    if (t[0UL])
+    {
+      i.tenant_value.capacity (i.tenant_size);
+      grew = true;
+    }
+
+    // canonical_name
+    //
+    if (t[1UL])
+    {
+      i.canonical_name_value.capacity (i.canonical_name_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::repository_id, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // tenant
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.tenant_value.data ();
+    b[n].capacity = i.tenant_value.capacity ();
+    b[n].size = &i.tenant_size;
+    b[n].is_null = &i.tenant_null;
+    n++;
+
+    // canonical_name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.canonical_name_value.data ();
+    b[n].capacity = i.canonical_name_value.capacity ();
+    b[n].size = &i.canonical_name_size;
+    b[n].is_null = &i.canonical_name_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::repository_id, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // tenant
+    //
+    {
+      ::std::string const& v =
+        o.tenant;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.tenant_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.tenant_value,
+        size,
+        is_null,
+        v);
+      i.tenant_null = is_null;
+      i.tenant_size = size;
+      grew = grew || (cap != i.tenant_value.capacity ());
+    }
+
+    // canonical_name
+    //
+    {
+      ::std::string const& v =
+        o.canonical_name;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.canonical_name_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.canonical_name_value,
+        size,
+        is_null,
+        v);
+      i.canonical_name_null = is_null;
+      i.canonical_name_size = size;
+      grew = grew || (cap != i.canonical_name_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::repository_id, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // tenant
+    //
+    {
+      ::std::string& v =
+        o.tenant;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.tenant_value,
+        i.tenant_size,
+        i.tenant_null);
+    }
+
+    // canonical_name
+    //
+    {
+      ::std::string& v =
+        o.canonical_name;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.canonical_name_value,
+        i.canonical_name_size,
+        i.canonical_name_null);
+    }
+  }
+}
+
+#include <odb/post.hxx>
diff --git a/libbrep/common-odb.hxx b/libbrep/common-odb.hxx
new file mode 100644
index 0000000..1bf0aaa
--- /dev/null
+++ b/libbrep/common-odb.hxx
@@ -0,0 +1,526 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#ifndef LIBBREP_COMMON_ODB_HXX
+#define LIBBREP_COMMON_ODB_HXX
+
+// Begin prologue.
+//
+#include <libbutl/small-vector-odb.hxx>
+#include <libbrep/wrapper-traits.hxx>
+#include <libbrep/common-traits.hxx>
+//
+// End prologue.
+
+#include <odb/version.hxx>
+
+#if (ODB_VERSION != 20470UL)
+#error ODB runtime version mismatch
+#endif
+
+#include <odb/pre.hxx>
+
+#include <libbrep/common.hxx>
+
+#include <memory>
+#include <cstddef>
+#include <utility>
+
+#include <odb/core.hxx>
+#include <odb/traits.hxx>
+#include <odb/callback.hxx>
+#include <odb/wrapper-traits.hxx>
+#include <odb/pointer-traits.hxx>
+#include <odb/container-traits.hxx>
+#include <odb/no-op-cache-traits.hxx>
+#include <odb/result.hxx>
+
+#include <odb/details/unused.hxx>
+#include <odb/details/shared-ptr.hxx>
+
+namespace odb
+{
+}
+
+#include <odb/details/buffer.hxx>
+
+#include <odb/pgsql/version.hxx>
+#include <odb/pgsql/forward.hxx>
+#include <odb/pgsql/binding.hxx>
+#include <odb/pgsql/pgsql-types.hxx>
+#include <odb/pgsql/query.hxx>
+
+namespace odb
+{
+  // _version
+  //
+  template <>
+  class access::composite_value_traits< ::brep::_version, id_pgsql >
+  {
+    public:
+    typedef ::brep::_version value_type;
+
+    struct image_type
+    {
+      // epoch
+      //
+      int epoch_value;
+      bool epoch_null;
+
+      // canonical_upstream
+      //
+      details::buffer canonical_upstream_value;
+      std::size_t canonical_upstream_size;
+      bool canonical_upstream_null;
+
+      // canonical_release
+      //
+      details::buffer canonical_release_value;
+      std::size_t canonical_release_size;
+      bool canonical_release_null;
+
+      // revision
+      //
+      int revision_value;
+      bool revision_null;
+
+      // upstream
+      //
+      details::buffer upstream_value;
+      std::size_t upstream_size;
+      bool upstream_null;
+
+      // release
+      //
+      details::buffer release_value;
+      std::size_t release_size;
+      bool release_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 6UL;
+  };
+
+  // build_constraint
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::build_constraint, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::build_constraint value_type;
+
+    struct image_type
+    {
+      // exclusion
+      //
+      bool exclusion_value;
+      bool exclusion_null;
+
+      // config
+      //
+      details::buffer config_value;
+      std::size_t config_size;
+      bool config_null;
+
+      // target
+      //
+      details::buffer target_value;
+      std::size_t target_size;
+      bool target_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 4UL;
+  };
+
+  // build_class_expr
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::build_class_expr, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::build_class_expr value_type;
+
+    struct image_type
+    {
+      // expression
+      //
+      details::buffer expression_value;
+      std::size_t expression_size;
+      bool expression_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // canonical_version
+  //
+  template <>
+  class access::composite_value_traits< ::brep::canonical_version, id_pgsql >
+  {
+    public:
+    typedef ::brep::canonical_version value_type;
+
+    struct image_type
+    {
+      // epoch
+      //
+      int epoch_value;
+      bool epoch_null;
+
+      // canonical_upstream
+      //
+      details::buffer canonical_upstream_value;
+      std::size_t canonical_upstream_size;
+      bool canonical_upstream_null;
+
+      // canonical_release
+      //
+      details::buffer canonical_release_value;
+      std::size_t canonical_release_size;
+      bool canonical_release_null;
+
+      // revision
+      //
+      int revision_value;
+      bool revision_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 4UL;
+  };
+
+  // upstream_version
+  //
+  template <>
+  class access::composite_value_traits< ::brep::upstream_version, id_pgsql >
+  {
+    public:
+    typedef ::brep::upstream_version value_type;
+
+    struct image_type
+    {
+      // upstream_
+      //
+      details::buffer upstream_value;
+      std::size_t upstream_size;
+      bool upstream_null;
+
+      // release_
+      //
+      details::buffer release_value;
+      std::size_t release_size;
+      bool release_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // package_id
+  //
+  template <>
+  class access::composite_value_traits< ::brep::package_id, id_pgsql >
+  {
+    public:
+    typedef ::brep::package_id value_type;
+
+    struct image_type
+    {
+      // tenant
+      //
+      details::buffer tenant_value;
+      std::size_t tenant_size;
+      bool tenant_null;
+
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // version
+      //
+      composite_value_traits< ::brep::canonical_version, id_pgsql >::image_type version_value;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 6UL;
+  };
+
+  // _repository_location
+  //
+  template <>
+  class access::composite_value_traits< ::brep::_repository_location, id_pgsql >
+  {
+    public:
+    typedef ::brep::_repository_location value_type;
+
+    struct image_type
+    {
+      // url
+      //
+      details::buffer url_value;
+      std::size_t url_size;
+      bool url_null;
+
+      // type
+      //
+      details::buffer type_value;
+      std::size_t type_size;
+      bool type_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // repository_id
+  //
+  template <>
+  class access::composite_value_traits< ::brep::repository_id, id_pgsql >
+  {
+    public:
+    typedef ::brep::repository_id value_type;
+
+    struct image_type
+    {
+      // tenant
+      //
+      details::buffer tenant_value;
+      std::size_t tenant_size;
+      bool tenant_null;
+
+      // canonical_name
+      //
+      details::buffer canonical_name_value;
+      std::size_t canonical_name_size;
+      bool canonical_name_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+}
+
+#include <libbrep/common-odb.ixx>
+
+#include <odb/post.hxx>
+
+#endif // LIBBREP_COMMON_ODB_HXX
diff --git a/libbrep/common-odb.ixx b/libbrep/common-odb.ixx
new file mode 100644
index 0000000..b8813df
--- /dev/null
+++ b/libbrep/common-odb.ixx
@@ -0,0 +1,239 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+namespace odb
+{
+}
+
+namespace odb
+{
+  // _version
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::_version, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.epoch_null;
+    r = r && i.canonical_upstream_null;
+    r = r && i.canonical_release_null;
+    r = r && i.revision_null;
+    r = r && i.upstream_null;
+    r = r && i.release_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::_version, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.epoch_null = true;
+    i.canonical_upstream_null = true;
+    i.canonical_release_null = true;
+    i.revision_null = true;
+    i.upstream_null = true;
+    i.release_null = true;
+  }
+
+  // build_constraint
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::build_constraint, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.exclusion_null;
+    r = r && i.config_null;
+    r = r && i.target_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::build_constraint, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.exclusion_null = true;
+    i.config_null = true;
+    i.target_null = true;
+    i.comment_null = true;
+  }
+
+  // build_class_expr
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::build_class_expr, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.expression_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::build_class_expr, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.expression_null = true;
+    i.comment_null = true;
+  }
+
+  // canonical_version
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::canonical_version, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.epoch_null;
+    r = r && i.canonical_upstream_null;
+    r = r && i.canonical_release_null;
+    r = r && i.revision_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::canonical_version, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.epoch_null = true;
+    i.canonical_upstream_null = true;
+    i.canonical_release_null = true;
+    i.revision_null = true;
+  }
+
+  // upstream_version
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::upstream_version, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.upstream_null;
+    r = r && i.release_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::upstream_version, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.upstream_null = true;
+    i.release_null = true;
+  }
+
+  // package_id
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::package_id, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.tenant_null;
+    r = r && i.name_null;
+    r = r && composite_value_traits< ::brep::canonical_version, id_pgsql >::get_null (i.version_value);
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::package_id, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.tenant_null = true;
+    i.name_null = true;
+    composite_value_traits< ::brep::canonical_version, id_pgsql >::set_null (i.version_value, sk);
+  }
+
+  // _repository_location
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::_repository_location, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.url_null;
+    r = r && i.type_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::_repository_location, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.url_null = true;
+    i.type_null = true;
+  }
+
+  // repository_id
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::repository_id, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.tenant_null;
+    r = r && i.canonical_name_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::repository_id, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.tenant_null = true;
+    i.canonical_name_null = true;
+  }
+}
+
diff --git a/libbrep/package-extra.hxx b/libbrep/package-extra.hxx
new file mode 100644
index 0000000..698cc75
--- /dev/null
+++ b/libbrep/package-extra.hxx
@@ -0,0 +1,541 @@
+  0x2d, 0x2d, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65,
+  0x20, 0x73, 0x68, 0x6f, 0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x70,
+  0x61, 0x72, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x62, 0x79, 0x20, 0x74,
+  0x68, 0x65, 0x20, 0x62, 0x72, 0x65, 0x70, 0x2d, 0x6d, 0x69, 0x67, 0x72,
+  0x61, 0x74, 0x65, 0x20, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e,
+  0x20, 0x54, 0x6f, 0x20, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65,
+  0x20, 0x74, 0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x70, 0x61, 0x72, 0x73,
+  0x65, 0x72, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x78, 0x69, 0x74,
+  0x79, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f,
+  0x77, 0x69, 0x6e, 0x67, 0x20, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63,
+  0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20, 0x70, 0x6c,
+  0x61, 0x63, 0x65, 0x64, 0x3a, 0x0a, 0x2d, 0x2d, 0x0a, 0x2d, 0x2d, 0x20,
+  0x2a, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6d,
+  0x75, 0x73, 0x74, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x77, 0x69,
+  0x74, 0x68, 0x20, 0x2d, 0x2d, 0x20, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65,
+  0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x6f,
+  0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x28,
+  0x69, 0x67, 0x6e, 0x6f, 0x72, 0x69, 0x6e, 0x67, 0x0a, 0x2d, 0x2d, 0x20,
+  0x20, 0x20, 0x6c, 0x65, 0x61, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x70,
+  0x61, 0x63, 0x65, 0x73, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x2a, 0x20, 0x6f,
+  0x6e, 0x6c, 0x79, 0x20, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x61,
+  0x6e, 0x64, 0x20, 0x44, 0x52, 0x4f, 0x50, 0x20, 0x73, 0x74, 0x61, 0x74,
+  0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x46,
+  0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x2c, 0x20, 0x54, 0x59, 0x50,
+  0x45, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x46, 0x4f, 0x52, 0x45, 0x49, 0x47,
+  0x4e, 0x20, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x0a, 0x2d, 0x2d, 0x20, 0x2a,
+  0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x6f,
+  0x64, 0x69, 0x65, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65,
+  0x20, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x75, 0x73, 0x69,
+  0x6e, 0x67, 0x20, 0x24, 0x24, 0x2d, 0x71, 0x75, 0x6f, 0x74, 0x65, 0x64,
+  0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x0a, 0x2d, 0x2d, 0x20,
+  0x2a, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x73, 0x20, 0x6f, 0x74,
+  0x68, 0x65, 0x72, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x66, 0x75, 0x6e,
+  0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x62, 0x6f, 0x64, 0x69, 0x65, 0x73,
+  0x20, 0x6d, 0x75, 0x73, 0x74, 0x20, 0x62, 0x65, 0x20, 0x71, 0x75, 0x6f,
+  0x74, 0x65, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x27, 0x20, 0x6f,
+  0x72, 0x20, 0x22, 0x0a, 0x2d, 0x2d, 0x20, 0x2a, 0x20, 0x73, 0x74, 0x61,
+  0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x6d, 0x75, 0x73, 0x74,
+  0x20, 0x65, 0x6e, 0x64, 0x20, 0x77, 0x69, 0x74, 0x68, 0x20, 0x22, 0x3b,
+  0x5c, 0x6e, 0x22, 0x0a, 0x2d, 0x2d, 0x0a, 0x2d, 0x2d, 0x20, 0x49, 0x6e,
+  0x63, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20,
+  0x64, 0x61, 0x74, 0x61, 0x62, 0x61, 0x73, 0x65, 0x20, 0x27, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x27, 0x20, 0x73, 0x63, 0x68, 0x65, 0x6d,
+  0x61, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x68,
+  0x65, 0x6e, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68,
+  0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x2e, 0x20, 0x4e, 0x6f, 0x74,
+  0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68,
+  0x65, 0x20, 0x62, 0x72, 0x65, 0x70, 0x2d, 0x6d, 0x69, 0x67, 0x72, 0x61,
+  0x74, 0x65, 0x20, 0x75, 0x74, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x65,
+  0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20,
+  0x64, 0x72, 0x6f, 0x70, 0x20, 0x53, 0x51, 0x4c, 0x20, 0x73, 0x74, 0x61,
+  0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x70, 0x72, 0x69, 0x6f,
+  0x72, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20,
+  0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x20, 0x6d, 0x69, 0x67, 0x72, 0x61,
+  0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65,
+  0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x73, 0x74, 0x61, 0x74,
+  0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x20, 0x61, 0x66, 0x74, 0x65, 0x72,
+  0x77, 0x61, 0x72, 0x64, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x61, 0x74, 0x2c,
+  0x20, 0x69, 0x6e, 0x20, 0x70, 0x61, 0x72, 0x74, 0x69, 0x63, 0x75, 0x6c,
+  0x61, 0x72, 0x2c, 0x0a, 0x2d, 0x2d, 0x20, 0x6d, 0x65, 0x61, 0x6e, 0x73,
+  0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x65, 0x78,
+  0x74, 0x72, 0x61, 0x73, 0x20, 0x6d, 0x61, 0x79, 0x20, 0x64, 0x65, 0x70,
+  0x65, 0x6e, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74,
+  0x61, 0x62, 0x6c, 0x65, 0x73, 0x20, 0x62, 0x75, 0x74, 0x20, 0x6e, 0x6f,
+  0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x20,
+  0x77, 0x61, 0x79, 0x0a, 0x2d, 0x2d, 0x20, 0x61, 0x72, 0x6f, 0x75, 0x6e,
+  0x64, 0x2e, 0x20, 0x4d, 0x61, 0x6b, 0x65, 0x20, 0x73, 0x75, 0x72, 0x65,
+  0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x64, 0x72,
+  0x6f, 0x70, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74,
+  0x73, 0x20, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x6c, 0x79, 0x20, 0x68,
+  0x61, 0x6e, 0x64, 0x6c, 0x65, 0x20, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x69,
+  0x65, 0x73, 0x20, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x0a, 0x2d,
+  0x2d, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x73, 0x63,
+  0x68, 0x65, 0x6d, 0x61, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x73, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x66,
+  0x72, 0x6f, 0x6d, 0x20, 0x4c, 0x49, 0x42, 0x42, 0x52, 0x45, 0x50, 0x5f,
+  0x50, 0x41, 0x43, 0x4b, 0x41, 0x47, 0x45, 0x5f, 0x53, 0x43, 0x48, 0x45,
+  0x4d, 0x41, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x42,
+  0x41, 0x53, 0x45, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x0a, 0x2d, 0x2d, 0x20,
+  0x54, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x20,
+  0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x64, 0x72, 0x6f, 0x70,
+  0x20, 0x74, 0x6f, 0x5f, 0x74, 0x73, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72,
+  0x28, 0x29, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x6c,
+  0x79, 0x2c, 0x20, 0x61, 0x73, 0x20, 0x77, 0x65, 0x20, 0x63, 0x61, 0x6e,
+  0x20, 0x72, 0x65, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x20, 0x22, 0x44, 0x52,
+  0x4f, 0x50, 0x0a, 0x2d, 0x2d, 0x20, 0x54, 0x59, 0x50, 0x45, 0x20, 0x49,
+  0x46, 0x20, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x20, 0x77, 0x65, 0x69,
+  0x67, 0x68, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x20, 0x43,
+  0x41, 0x53, 0x43, 0x41, 0x44, 0x45, 0x22, 0x20, 0x73, 0x74, 0x61, 0x74,
+  0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x62, 0x65, 0x6c, 0x6f, 0x77, 0x2c,
+  0x20, 0x77, 0x68, 0x69, 0x63, 0x68, 0x20, 0x77, 0x69, 0x6c, 0x6c, 0x20,
+  0x64, 0x72, 0x6f, 0x70, 0x20, 0x61, 0x6c, 0x6c, 0x0a, 0x2d, 0x2d, 0x20,
+  0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74,
+  0x20, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x20, 0x6f, 0x6e, 0x20, 0x74,
+  0x68, 0x69, 0x73, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2e, 0x20, 0x4d, 0x6f,
+  0x72, 0x65, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20,
+  0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f,
+  0x4e, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20,
+  0x77, 0x69, 0x6c, 0x6c, 0x0a, 0x2d, 0x2d, 0x20, 0x66, 0x61, 0x69, 0x6c,
+  0x20, 0x66, 0x6f, 0x72, 0x20, 0x6f, 0x6c, 0x64, 0x20, 0x76, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x50, 0x6f, 0x73,
+  0x74, 0x67, 0x72, 0x65, 0x53, 0x51, 0x4c, 0x20, 0x28, 0x65, 0x78, 0x70,
+  0x65, 0x72, 0x69, 0x65, 0x6e, 0x63, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72,
+  0x20, 0x39, 0x2e, 0x32, 0x2e, 0x31, 0x34, 0x29, 0x20, 0x77, 0x69, 0x74,
+  0x68, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x3a, 0x0a, 0x2d, 0x2d, 0x20,
+  0x74, 0x79, 0x70, 0x65, 0x20, 0x22, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
+  0x65, 0x64, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x22, 0x20, 0x64, 0x6f, 0x65,
+  0x73, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x65, 0x78, 0x69, 0x73, 0x74, 0x2e,
+  0x0a, 0x2d, 0x2d, 0x0a, 0x2d, 0x2d, 0x20, 0x44, 0x52, 0x4f, 0x50, 0x20,
+  0x46, 0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x20, 0x49, 0x46, 0x20,
+  0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x20, 0x74, 0x6f, 0x5f, 0x74, 0x73,
+  0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x28, 0x49, 0x4e, 0x20, 0x64, 0x6f,
+  0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x65, 0x69, 0x67, 0x68,
+  0x74, 0x65, 0x64, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x29, 0x3b, 0x0a, 0x2d,
+  0x2d, 0x0a, 0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x55, 0x4e, 0x43, 0x54,
+  0x49, 0x4f, 0x4e, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58, 0x49, 0x53, 0x54,
+  0x53, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x70, 0x61, 0x63,
+  0x6b, 0x61, 0x67, 0x65, 0x73, 0x28, 0x49, 0x4e, 0x20, 0x71, 0x75, 0x65,
+  0x72, 0x79, 0x20, 0x74, 0x73, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2c, 0x0a,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x49, 0x4e, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+  0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x49, 0x4e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x49, 0x54, 0x45,
+  0x58, 0x54, 0x29, 0x3b, 0x0a, 0x0a, 0x44, 0x52, 0x4f, 0x50, 0x20, 0x46,
+  0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x20, 0x49, 0x46, 0x20, 0x45,
+  0x58, 0x49, 0x53, 0x54, 0x53, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68,
+  0x5f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b,
+  0x61, 0x67, 0x65, 0x73, 0x28, 0x49, 0x4e, 0x20, 0x71, 0x75, 0x65, 0x72,
+  0x79, 0x20, 0x74, 0x73, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2c, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x49, 0x4e,
+  0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54,
+  0x29, 0x3b, 0x0a, 0x0a, 0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x55, 0x4e,
+  0x43, 0x54, 0x49, 0x4f, 0x4e, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58, 0x49,
+  0x53, 0x54, 0x53, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70,
+  0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x28, 0x49, 0x4e, 0x20, 0x74, 0x65,
+  0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x20, 0x49,
+  0x4e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x49, 0x54, 0x45, 0x58,
+  0x54, 0x29, 0x3b, 0x0a, 0x44, 0x52, 0x4f, 0x50, 0x20, 0x46, 0x55, 0x4e,
+  0x43, 0x54, 0x49, 0x4f, 0x4e, 0x20, 0x49, 0x46, 0x20, 0x45, 0x58, 0x49,
+  0x53, 0x54, 0x53, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70,
+  0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x28, 0x49, 0x4e, 0x20, 0x74,
+  0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x29, 0x3b,
+  0x0a, 0x0a, 0x44, 0x52, 0x4f, 0x50, 0x20, 0x54, 0x59, 0x50, 0x45, 0x20,
+  0x49, 0x46, 0x20, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x20, 0x77, 0x65,
+  0x69, 0x67, 0x68, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x20,
+  0x43, 0x41, 0x53, 0x43, 0x41, 0x44, 0x45, 0x3b, 0x0a, 0x43, 0x52, 0x45,
+  0x41, 0x54, 0x45, 0x20, 0x54, 0x59, 0x50, 0x45, 0x20, 0x77, 0x65, 0x69,
+  0x67, 0x68, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x20, 0x41,
+  0x53, 0x20, 0x28, 0x61, 0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x20, 0x62,
+  0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x20, 0x63, 0x20, 0x54, 0x45, 0x58,
+  0x54, 0x2c, 0x20, 0x64, 0x20, 0x54, 0x45, 0x58, 0x54, 0x29, 0x3b, 0x0a,
+  0x0a, 0x2d, 0x2d, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x74,
+  0x68, 0x65, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x76, 0x65,
+  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x6f, 0x66, 0x20, 0x6d, 0x61,
+  0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x74, 0x65, 0x6e,
+  0x61, 0x6e, 0x74, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
+  0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20, 0x61, 0x73,
+  0x20, 0x61, 0x20, 0x73, 0x65, 0x74, 0x0a, 0x2d, 0x2d, 0x20, 0x6f, 0x66,
+  0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x72, 0x6f, 0x77,
+  0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74,
+  0x20, 0x69, 0x73, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x20, 0x74, 0x68,
+  0x65, 0x6e, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x6c, 0x6c,
+  0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x2d, 0x2d,
+  0x0a, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46, 0x55, 0x4e, 0x43,
+  0x54, 0x49, 0x4f, 0x4e, 0x0a, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f,
+  0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x28, 0x49, 0x4e, 0x20,
+  0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x29,
+  0x0a, 0x52, 0x45, 0x54, 0x55, 0x52, 0x4e, 0x53, 0x20, 0x53, 0x45, 0x54,
+  0x4f, 0x46, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x41,
+  0x53, 0x20, 0x24, 0x24, 0x0a, 0x20, 0x20, 0x53, 0x45, 0x4c, 0x45, 0x43,
+  0x54, 0x20, 0x70, 0x31, 0x2e, 0x2a, 0x0a, 0x20, 0x20, 0x46, 0x52, 0x4f,
+  0x4d, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x70, 0x31,
+  0x20, 0x4c, 0x45, 0x46, 0x54, 0x20, 0x4a, 0x4f, 0x49, 0x4e, 0x20, 0x70,
+  0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x70, 0x32, 0x20, 0x4f, 0x4e,
+  0x20, 0x28, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x31, 0x2e, 0x69, 0x6e,
+  0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x70, 0x6f, 0x73,
+  0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69,
+  0x63, 0x61, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x49, 0x53, 0x20,
+  0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x41, 0x4e, 0x44,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x31, 0x2e, 0x74, 0x65, 0x6e, 0x61,
+  0x6e, 0x74, 0x20, 0x3d, 0x20, 0x70, 0x32, 0x2e, 0x74, 0x65, 0x6e, 0x61,
+  0x6e, 0x74, 0x20, 0x41, 0x4e, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70,
+  0x31, 0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x3d, 0x20, 0x70, 0x32, 0x2e,
+  0x6e, 0x61, 0x6d, 0x65, 0x20, 0x41, 0x4e, 0x44, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x70, 0x32, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c,
+  0x5f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f,
+  0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x6e, 0x61,
+  0x6d, 0x65, 0x20, 0x49, 0x53, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55,
+  0x4c, 0x4c, 0x20, 0x41, 0x4e, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x28,
+  0x70, 0x31, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65,
+  0x70, 0x6f, 0x63, 0x68, 0x20, 0x3c, 0x20, 0x70, 0x32, 0x2e, 0x76, 0x65,
+  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x20,
+  0x4f, 0x52, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x70, 0x31, 0x2e, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+  0x20, 0x3d, 0x20, 0x70, 0x32, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x20, 0x41, 0x4e, 0x44, 0x0a,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x28, 0x70, 0x31, 0x2e, 0x76, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63,
+  0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20,
+  0x3c, 0x20, 0x70, 0x32, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75,
+  0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x4f, 0x52, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x70, 0x31, 0x2e, 0x76, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61,
+  0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x3d,
+  0x20, 0x70, 0x32, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+  0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x70,
+  0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x41, 0x4e, 0x44, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x28, 0x70, 0x31, 0x2e, 0x76, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63,
+  0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x3c,
+  0x20, 0x70, 0x32, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+  0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x65,
+  0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x4f, 0x52, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x70, 0x31, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69,
+  0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c,
+  0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x3d, 0x20, 0x70,
+  0x32, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61,
+  0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65,
+  0x61, 0x73, 0x65, 0x20, 0x41, 0x4e, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x70, 0x31, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x3c,
+  0x20, 0x70, 0x32, 0x2e, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+  0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x29, 0x29, 0x29, 0x29,
+  0x0a, 0x20, 0x20, 0x57, 0x48, 0x45, 0x52, 0x45, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x28, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63,
+  0x6b, 0x61, 0x67, 0x65, 0x73, 0x2e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74,
+  0x20, 0x49, 0x53, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x4f, 0x52, 0x20,
+  0x70, 0x31, 0x2e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x3d, 0x20,
+  0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61,
+  0x67, 0x65, 0x73, 0x2e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x29, 0x20,
+  0x41, 0x4e, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x31, 0x2e, 0x69,
+  0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x70, 0x6f,
+  0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e,
+  0x69, 0x63, 0x61, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x49, 0x53,
+  0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x41, 0x4e,
+  0x44, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x32, 0x2e, 0x6e, 0x61, 0x6d,
+  0x65, 0x20, 0x49, 0x53, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x3b, 0x0a, 0x24,
+  0x24, 0x20, 0x4c, 0x41, 0x4e, 0x47, 0x55, 0x41, 0x47, 0x45, 0x20, 0x53,
+  0x51, 0x4c, 0x20, 0x53, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x3b, 0x0a, 0x0a,
+  0x2d, 0x2d, 0x20, 0x46, 0x69, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x20,
+  0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69,
+  0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74,
+  0x65, 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65,
+  0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x74,
+  0x65, 0x6e, 0x61, 0x6e, 0x74, 0x0a, 0x2d, 0x2d, 0x20, 0x61, 0x6e, 0x64,
+  0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72,
+  0x6e, 0x20, 0x61, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x20, 0x72,
+  0x6f, 0x77, 0x20, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e,
+  0x67, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x20, 0x69, 0x64, 0x2c, 0x20, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x20,
+  0x72, 0x6f, 0x77, 0x20, 0x73, 0x65, 0x74, 0x20, 0x69, 0x66, 0x0a, 0x2d,
+  0x2d, 0x20, 0x74, 0x68, 0x65, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x2e,
+  0x0a, 0x2d, 0x2d, 0x0a, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46,
+  0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x0a, 0x6c, 0x61, 0x74, 0x65,
+  0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x28, 0x49,
+  0x4e, 0x4f, 0x55, 0x54, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20,
+  0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x49, 0x4e, 0x4f,
+  0x55, 0x54, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x43, 0x49, 0x54, 0x45,
+  0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+  0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x2c, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x4f, 0x55, 0x54, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75,
+  0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x20, 0x54, 0x45, 0x58, 0x54,
+  0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x76, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63,
+  0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x54,
+  0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69,
+  0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52,
+  0x29, 0x0a, 0x52, 0x45, 0x54, 0x55, 0x52, 0x4e, 0x53, 0x20, 0x53, 0x45,
+  0x54, 0x4f, 0x46, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x20, 0x41,
+  0x53, 0x20, 0x24, 0x24, 0x0a, 0x20, 0x20, 0x53, 0x45, 0x4c, 0x45, 0x43,
+  0x54, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x2c, 0x20, 0x6e, 0x61,
+  0x6d, 0x65, 0x2c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+  0x65, 0x70, 0x6f, 0x63, 0x68, 0x2c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69,
+  0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c,
+  0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2c, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65, 0x72, 0x73,
+  0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61,
+  0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x2c, 0x20, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73,
+  0x69, 0x6f, 0x6e, 0x0a, 0x20, 0x20, 0x46, 0x52, 0x4f, 0x4d, 0x20, 0x6c,
+  0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x73, 0x28, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74,
+  0x29, 0x0a, 0x20, 0x20, 0x57, 0x48, 0x45, 0x52, 0x45, 0x20, 0x6e, 0x61,
+  0x6d, 0x65, 0x20, 0x3d, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f,
+  0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6e, 0x61, 0x6d, 0x65,
+  0x3b, 0x0a, 0x24, 0x24, 0x20, 0x4c, 0x41, 0x4e, 0x47, 0x55, 0x41, 0x47,
+  0x45, 0x20, 0x53, 0x51, 0x4c, 0x20, 0x53, 0x54, 0x41, 0x42, 0x4c, 0x45,
+  0x3b, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68,
+  0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c, 0x61, 0x74,
+  0x65, 0x73, 0x74, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+  0x6f, 0x66, 0x20, 0x61, 0x6e, 0x20, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e,
+  0x61, 0x6c, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x20,
+  0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65,
+  0x0a, 0x2d, 0x2d, 0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65,
+  0x64, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x71, 0x75, 0x65,
+  0x72, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+  0x74, 0x2e, 0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20,
+  0x73, 0x65, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x20,
+  0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74,
+  0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x20, 0x69, 0x64, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x61,
+  0x72, 0x63, 0x68, 0x20, 0x72, 0x61, 0x6e, 0x6b, 0x2e, 0x20, 0x49, 0x66,
+  0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x69, 0x73, 0x20, 0x4e, 0x55,
+  0x4c, 0x4c, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x6d, 0x61, 0x74,
+  0x63, 0x68, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61,
+  0x67, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64, 0x0a, 0x2d, 0x2d, 0x20, 0x72,
+  0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x30, 0x20, 0x72, 0x61, 0x6e, 0x6b,
+  0x20, 0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x72, 0x6f, 0x77,
+  0x73, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74,
+  0x20, 0x69, 0x73, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x20, 0x74, 0x68,
+  0x65, 0x6e, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x6c, 0x6c,
+  0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x2d, 0x2d,
+  0x0a, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46, 0x55, 0x4e, 0x43,
+  0x54, 0x49, 0x4f, 0x4e, 0x0a, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f,
+  0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61,
+  0x67, 0x65, 0x73, 0x28, 0x49, 0x4e, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79,
+  0x20, 0x74, 0x73, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2c, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x49, 0x4e, 0x4f,
+  0x55, 0x54, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45,
+  0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20,
+  0x43, 0x49, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68,
+  0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x2c, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54,
+  0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e,
+  0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72,
+  0x65, 0x61, 0x6d, 0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54,
+  0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e,
+  0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61,
+  0x73, 0x65, 0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20,
+  0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69,
+  0x73, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52,
+  0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x4f, 0x55, 0x54, 0x20, 0x72, 0x61, 0x6e, 0x6b, 0x20, 0x72, 0x65,
+  0x61, 0x6c, 0x29, 0x0a, 0x52, 0x45, 0x54, 0x55, 0x52, 0x4e, 0x53, 0x20,
+  0x53, 0x45, 0x54, 0x4f, 0x46, 0x20, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64,
+  0x20, 0x41, 0x53, 0x20, 0x24, 0x24, 0x0a, 0x20, 0x20, 0x53, 0x45, 0x4c,
+  0x45, 0x43, 0x54, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x2c, 0x20,
+  0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x2c, 0x20, 0x76, 0x65, 0x72,
+  0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63,
+  0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2c,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x76, 0x65,
+  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69,
+  0x63, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x2c,
+  0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x76,
+  0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x43, 0x41, 0x53, 0x45, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x57, 0x48, 0x45, 0x4e,
+  0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x49, 0x53, 0x20, 0x4e, 0x55,
+  0x4c, 0x4c, 0x20, 0x54, 0x48, 0x45, 0x4e, 0x20, 0x30, 0x0a, 0x2d, 0x2d,
+  0x20, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x6d, 0x61, 0x70, 0x70,
+  0x69, 0x6e, 0x67, 0x3a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x44, 0x20, 0x20, 0x20, 0x20, 0x20, 0x43, 0x20, 0x20,
+  0x20, 0x20, 0x42, 0x20, 0x20, 0x20, 0x20, 0x41, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x45, 0x4c, 0x53, 0x45,
+  0x20, 0x74, 0x73, 0x5f, 0x72, 0x61, 0x6e, 0x6b, 0x5f, 0x63, 0x64, 0x28,
+  0x27, 0x7b, 0x30, 0x2e, 0x30, 0x35, 0x2c, 0x20, 0x30, 0x2e, 0x32, 0x2c,
+  0x20, 0x30, 0x2e, 0x39, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x7d, 0x27, 0x2c,
+  0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65,
+  0x78, 0x2c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x29, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x45, 0x4e, 0x44, 0x20, 0x41,
+  0x53, 0x20, 0x72, 0x61, 0x6e, 0x6b, 0x0a, 0x20, 0x20, 0x46, 0x52, 0x4f,
+  0x4d, 0x20, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63,
+  0x6b, 0x61, 0x67, 0x65, 0x73, 0x28, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68,
+  0x5f, 0x6c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x63, 0x6b,
+  0x61, 0x67, 0x65, 0x73, 0x2e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x29,
+  0x0a, 0x20, 0x20, 0x57, 0x48, 0x45, 0x52, 0x45, 0x20, 0x71, 0x75, 0x65,
+  0x72, 0x79, 0x20, 0x49, 0x53, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x4f,
+  0x52, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64,
+  0x65, 0x78, 0x20, 0x40, 0x40, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x3b,
+  0x0a, 0x24, 0x24, 0x20, 0x4c, 0x41, 0x4e, 0x47, 0x55, 0x41, 0x47, 0x45,
+  0x20, 0x53, 0x51, 0x4c, 0x20, 0x53, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x3b,
+  0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20,
+  0x66, 0x6f, 0x72, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73,
+  0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68,
+  0x65, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x20, 0x71, 0x75, 0x65,
+  0x72, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e,
+  0x74, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67,
+  0x20, 0x74, 0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x73, 0x70, 0x65, 0x63,
+  0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2e,
+  0x20, 0x52, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x73, 0x65,
+  0x74, 0x20, 0x6f, 0x66, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x20, 0x63, 0x6f,
+  0x6e, 0x74, 0x61, 0x69, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x68, 0x65,
+  0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x20, 0x69, 0x64, 0x20,
+  0x61, 0x6e, 0x64, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x0a, 0x2d,
+  0x2d, 0x20, 0x72, 0x61, 0x6e, 0x6b, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x71,
+  0x75, 0x65, 0x72, 0x79, 0x20, 0x69, 0x73, 0x20, 0x4e, 0x55, 0x4c, 0x4c,
+  0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x6d, 0x61, 0x74, 0x63, 0x68,
+  0x20, 0x61, 0x6c, 0x6c, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
+  0x73, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
+  0x20, 0x30, 0x20, 0x72, 0x61, 0x6e, 0x6b, 0x20, 0x66, 0x6f, 0x72, 0x20,
+  0x61, 0x6c, 0x6c, 0x0a, 0x2d, 0x2d, 0x20, 0x72, 0x6f, 0x77, 0x73, 0x2e,
+  0x20, 0x49, 0x66, 0x20, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x69,
+  0x73, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x20, 0x74, 0x68, 0x65, 0x6e,
+  0x20, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x74,
+  0x65, 0x6e, 0x61, 0x6e, 0x74, 0x73, 0x2e, 0x0a, 0x2d, 0x2d, 0x0a, 0x43,
+  0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46, 0x55, 0x4e, 0x43, 0x54, 0x49,
+  0x4f, 0x4e, 0x0a, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x70, 0x61,
+  0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x28, 0x49, 0x4e, 0x20, 0x71, 0x75,
+  0x65, 0x72, 0x79, 0x20, 0x74, 0x73, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2c,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x49, 0x4e, 0x4f, 0x55, 0x54, 0x20, 0x74,
+  0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x49, 0x4e, 0x4f, 0x55, 0x54, 0x20, 0x6e, 0x61,
+  0x6d, 0x65, 0x20, 0x43, 0x49, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69,
+  0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x20, 0x49, 0x4e, 0x54,
+  0x45, 0x47, 0x45, 0x52, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55,
+  0x54, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61,
+  0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74,
+  0x72, 0x65, 0x61, 0x6d, 0x20, 0x54, 0x45, 0x58, 0x54, 0x2c, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69,
+  0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c,
+  0x5f, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x54, 0x45, 0x58,
+  0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x76,
+  0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73,
+  0x69, 0x6f, 0x6e, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x2c,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x55, 0x54, 0x20, 0x72, 0x61, 0x6e,
+  0x6b, 0x20, 0x72, 0x65, 0x61, 0x6c, 0x29, 0x0a, 0x52, 0x45, 0x54, 0x55,
+  0x52, 0x4e, 0x53, 0x20, 0x53, 0x45, 0x54, 0x4f, 0x46, 0x20, 0x72, 0x65,
+  0x63, 0x6f, 0x72, 0x64, 0x20, 0x41, 0x53, 0x20, 0x24, 0x24, 0x0a, 0x20,
+  0x20, 0x53, 0x45, 0x4c, 0x45, 0x43, 0x54, 0x20, 0x74, 0x65, 0x6e, 0x61,
+  0x6e, 0x74, 0x2c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, 0x76, 0x65,
+  0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x2c,
+  0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6e,
+  0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x75, 0x70, 0x73, 0x74, 0x72,
+  0x65, 0x61, 0x6d, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61,
+  0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x6c, 0x65,
+  0x61, 0x73, 0x65, 0x2c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x2c, 0x0a, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x43, 0x41, 0x53, 0x45,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x57, 0x48, 0x45, 0x4e, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20, 0x49,
+  0x53, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x54, 0x48, 0x45, 0x4e, 0x20,
+  0x30, 0x0a, 0x2d, 0x2d, 0x20, 0x57, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20,
+  0x6d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x3a, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x44, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x43, 0x20, 0x20, 0x20, 0x20, 0x42, 0x20, 0x20, 0x20, 0x20, 0x41,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x45, 0x4c, 0x53, 0x45, 0x20, 0x74, 0x73, 0x5f, 0x72, 0x61, 0x6e, 0x6b,
+  0x5f, 0x63, 0x64, 0x28, 0x27, 0x7b, 0x30, 0x2e, 0x30, 0x35, 0x2c, 0x20,
+  0x30, 0x2e, 0x32, 0x2c, 0x20, 0x30, 0x2e, 0x39, 0x2c, 0x20, 0x31, 0x2e,
+  0x30, 0x7d, 0x27, 0x2c, 0x20, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f,
+  0x69, 0x6e, 0x64, 0x65, 0x78, 0x2c, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79,
+  0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x45,
+  0x4e, 0x44, 0x20, 0x41, 0x53, 0x20, 0x72, 0x61, 0x6e, 0x6b, 0x0a, 0x20,
+  0x20, 0x46, 0x52, 0x4f, 0x4d, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
+  0x65, 0x0a, 0x20, 0x20, 0x57, 0x48, 0x45, 0x52, 0x45, 0x0a, 0x20, 0x20,
+  0x28, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x70, 0x61, 0x63, 0x6b,
+  0x61, 0x67, 0x65, 0x73, 0x2e, 0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20,
+  0x49, 0x53, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x4f, 0x52, 0x20, 0x74,
+  0x65, 0x6e, 0x61, 0x6e, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x65, 0x61, 0x72,
+  0x63, 0x68, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x2e,
+  0x74, 0x65, 0x6e, 0x61, 0x6e, 0x74, 0x29, 0x20, 0x41, 0x4e, 0x44, 0x0a,
+  0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x3d, 0x20, 0x73, 0x65, 0x61,
+  0x72, 0x63, 0x68, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73,
+  0x2e, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x41, 0x4e, 0x44, 0x0a, 0x20, 0x20,
+  0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x65, 0x70,
+  0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x63, 0x61, 0x6e, 0x6f,
+  0x6e, 0x69, 0x63, 0x61, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x49,
+  0x53, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x41,
+  0x4e, 0x44, 0x0a, 0x20, 0x20, 0x28, 0x71, 0x75, 0x65, 0x72, 0x79, 0x20,
+  0x49, 0x53, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x4f, 0x52, 0x20, 0x73,
+  0x65, 0x61, 0x72, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x20,
+  0x40, 0x40, 0x20, 0x71, 0x75, 0x65, 0x72, 0x79, 0x29, 0x3b, 0x0a, 0x24,
+  0x24, 0x20, 0x4c, 0x41, 0x4e, 0x47, 0x55, 0x41, 0x47, 0x45, 0x20, 0x53,
+  0x51, 0x4c, 0x20, 0x53, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x3b, 0x0a, 0x0a,
+  0x2d, 0x2d, 0x20, 0x50, 0x61, 0x72, 0x73, 0x65, 0x20, 0x77, 0x65, 0x69,
+  0x67, 0x68, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x20, 0x74,
+  0x6f, 0x20, 0x74, 0x73, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x2e, 0x0a,
+  0x2d, 0x2d, 0x0a, 0x43, 0x52, 0x45, 0x41, 0x54, 0x45, 0x20, 0x46, 0x55,
+  0x4e, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x0a, 0x74, 0x6f, 0x5f, 0x74, 0x73,
+  0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x28, 0x49, 0x4e, 0x20, 0x64, 0x6f,
+  0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x77, 0x65, 0x69, 0x67, 0x68,
+  0x74, 0x65, 0x64, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x29, 0x0a, 0x52, 0x45,
+  0x54, 0x55, 0x52, 0x4e, 0x53, 0x20, 0x74, 0x73, 0x76, 0x65, 0x63, 0x74,
+  0x6f, 0x72, 0x20, 0x41, 0x53, 0x20, 0x24, 0x24, 0x0a, 0x20, 0x20, 0x53,
+  0x45, 0x4c, 0x45, 0x43, 0x54, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x43, 0x41,
+  0x53, 0x45, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x57, 0x48, 0x45,
+  0x4e, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x49,
+  0x53, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x20, 0x54, 0x48, 0x45, 0x4e, 0x20,
+  0x4e, 0x55, 0x4c, 0x4c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x45,
+  0x4c, 0x53, 0x45, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x73, 0x65, 0x74, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x28, 0x74, 0x6f,
+  0x5f, 0x74, 0x73, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x28, 0x64, 0x6f,
+  0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x61, 0x29, 0x2c, 0x20, 0x27,
+  0x41, 0x27, 0x29, 0x20, 0x7c, 0x7c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x73, 0x65, 0x74, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74,
+  0x28, 0x74, 0x6f, 0x5f, 0x74, 0x73, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72,
+  0x28, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x62, 0x29,
+  0x2c, 0x20, 0x27, 0x42, 0x27, 0x29, 0x20, 0x7c, 0x7c, 0x0a, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x65, 0x74, 0x77, 0x65, 0x69,
+  0x67, 0x68, 0x74, 0x28, 0x74, 0x6f, 0x5f, 0x74, 0x73, 0x76, 0x65, 0x63,
+  0x74, 0x6f, 0x72, 0x28, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74,
+  0x2e, 0x63, 0x29, 0x2c, 0x20, 0x27, 0x43, 0x27, 0x29, 0x20, 0x7c, 0x7c,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x65, 0x74,
+  0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x28, 0x74, 0x6f, 0x5f, 0x74, 0x73,
+  0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x28, 0x64, 0x6f, 0x63, 0x75, 0x6d,
+  0x65, 0x6e, 0x74, 0x2e, 0x64, 0x29, 0x2c, 0x20, 0x27, 0x44, 0x27, 0x29,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x45, 0x4e, 0x44, 0x0a, 0x24, 0x24, 0x20,
+  0x4c, 0x41, 0x4e, 0x47, 0x55, 0x41, 0x47, 0x45, 0x20, 0x53, 0x51, 0x4c,
+  0x20, 0x49, 0x4d, 0x4d, 0x55, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x3b, 0x0a
diff --git a/libbrep/package-odb.cxx b/libbrep/package-odb.cxx
new file mode 100644
index 0000000..a75d5af
--- /dev/null
+++ b/libbrep/package-odb.cxx
@@ -0,0 +1,14202 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#include <odb/pre.hxx>
+
+#include <libbrep/package-odb.hxx>
+
+#include <cassert>
+#include <cstring>  // std::memcpy
+
+#include <odb/schema-catalog-impl.hxx>
+
+#include <odb/pgsql/traits.hxx>
+#include <odb/pgsql/database.hxx>
+#include <odb/pgsql/transaction.hxx>
+#include <odb/pgsql/connection.hxx>
+#include <odb/pgsql/statement.hxx>
+#include <odb/pgsql/statement-cache.hxx>
+#include <odb/pgsql/simple-object-statements.hxx>
+#include <odb/pgsql/view-statements.hxx>
+#include <odb/pgsql/section-statements.hxx>
+#include <odb/pgsql/container-statements.hxx>
+#include <odb/pgsql/exceptions.hxx>
+#include <odb/pgsql/prepared-query.hxx>
+#include <odb/pgsql/simple-object-result.hxx>
+#include <odb/pgsql/view-result.hxx>
+
+namespace odb
+{
+  // priority
+  //
+
+  bool access::composite_value_traits< ::bpkg::priority, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // value
+    //
+    t[0UL] = 0;
+
+    // comment
+    //
+    if (t[1UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::priority, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // value
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.value_value;
+    b[n].is_null = &i.value_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::priority, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // value
+    //
+    {
+      ::bpkg::priority::value_type const& v =
+        o.value;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::bpkg::priority::value_type,
+          pgsql::id_integer >::set_image (
+        i.value_value, is_null, v);
+      i.value_null = is_null;
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::priority, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // value
+    //
+    {
+      ::bpkg::priority::value_type& v =
+        o.value;
+
+      pgsql::value_traits<
+          ::bpkg::priority::value_type,
+          pgsql::id_integer >::set_value (
+        v,
+        i.value_value,
+        i.value_null);
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // licenses
+  //
+
+  bool access::composite_value_traits< ::bpkg::licenses, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // comment
+    //
+    if (t[0UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::licenses, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::licenses, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::licenses, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // manifest_url
+  //
+
+  bool access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // value
+    //
+    if (t[0UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    // comment
+    //
+    if (t[1UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // value
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.value_value.data ();
+    b[n].capacity = i.value_value.capacity ();
+    b[n].size = &i.value_size;
+    b[n].is_null = &i.value_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // value
+    //
+    {
+      // From package.hxx:68:5
+      ::std::string const& v =
+        o.string ();
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.value_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.value_value,
+        size,
+        is_null,
+        v);
+      i.value_null = is_null;
+      i.value_size = size;
+      grew = grew || (cap != i.value_value.capacity ());
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // value
+    //
+    {
+      // From package.hxx:69:5
+      ::std::string v;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+
+      // From package.hxx:69:5
+      o = brep::manifest_url ((v), "");
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // email
+  //
+
+  bool access::composite_value_traits< ::bpkg::email, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // value
+    //
+    if (t[0UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    // comment
+    //
+    if (t[1UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::email, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // value
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.value_value.data ();
+    b[n].capacity = i.value_value.capacity ();
+    b[n].size = &i.value_size;
+    b[n].is_null = &i.value_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::email, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // value
+    //
+    {
+      // From package.hxx:77:58
+      ::std::string const& v =
+        o;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.value_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.value_value,
+        size,
+        is_null,
+        v);
+      i.value_null = is_null;
+      i.value_size = size;
+      grew = grew || (cap != i.value_value.capacity ());
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::email, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // value
+    //
+    {
+      // From package.hxx:77:58
+      ::std::string& v =
+        o;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // version_constraint
+  //
+
+  bool access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // min_version
+    //
+    if (composite_value_traits< ::brep::_version, id_pgsql >::grow (
+          i.min_version_value, t + 0UL))
+      grew = true;
+
+    // max_version
+    //
+    if (composite_value_traits< ::brep::_version, id_pgsql >::grow (
+          i.max_version_value, t + 6UL))
+      grew = true;
+
+    // min_open
+    //
+    t[12UL] = 0;
+
+    // max_open
+    //
+    t[13UL] = 0;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // min_version
+    //
+    composite_value_traits< ::brep::_version, id_pgsql >::bind (
+      b + n, i.min_version_value, sk);
+    n += 6UL;
+
+    // max_version
+    //
+    composite_value_traits< ::brep::_version, id_pgsql >::bind (
+      b + n, i.max_version_value, sk);
+    n += 6UL;
+
+    // min_open
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.min_open_value;
+    b[n].is_null = &i.min_open_null;
+    n++;
+
+    // max_open
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.max_open_value;
+    b[n].is_null = &i.max_open_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // min_version
+    //
+    {
+      ::butl::optional< ::bpkg::version > const& v =
+        o.min_version;
+
+      // From common.hxx:75:12
+      ::brep::_optional_version const& vt =
+        (v) ? brep::_version 
+      {
+         (v)->epoch, (v)->canonical_upstream, (v)->canonical_release, (v)->revision, (v)->upstream, (v)->release 
+      } : brep::_optional_version ();
+
+      if (wrapper_traits< ::brep::_optional_version >::get_null (vt))
+        composite_value_traits< ::brep::_version, id_pgsql >::set_null (
+          i.min_version_value, sk);
+      else
+      {
+        const::brep::_version& vw = 
+          wrapper_traits< ::brep::_optional_version >::get_ref (vt);
+
+        if (composite_value_traits< ::brep::_version, id_pgsql >::init (
+              i.min_version_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // max_version
+    //
+    {
+      ::butl::optional< ::bpkg::version > const& v =
+        o.max_version;
+
+      // From common.hxx:75:12
+      ::brep::_optional_version const& vt =
+        (v) ? brep::_version 
+      {
+         (v)->epoch, (v)->canonical_upstream, (v)->canonical_release, (v)->revision, (v)->upstream, (v)->release 
+      } : brep::_optional_version ();
+
+      if (wrapper_traits< ::brep::_optional_version >::get_null (vt))
+        composite_value_traits< ::brep::_version, id_pgsql >::set_null (
+          i.max_version_value, sk);
+      else
+      {
+        const::brep::_version& vw = 
+          wrapper_traits< ::brep::_optional_version >::get_ref (vt);
+
+        if (composite_value_traits< ::brep::_version, id_pgsql >::init (
+              i.max_version_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // min_open
+    //
+    {
+      bool const& v =
+        o.min_open;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.min_open_value, is_null, v);
+      i.min_open_null = is_null;
+    }
+
+    // max_open
+    //
+    {
+      bool const& v =
+        o.max_open;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.max_open_value, is_null, v);
+      i.max_open_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // min_version
+    //
+    {
+      ::butl::optional< ::bpkg::version >& v =
+        o.min_version;
+
+      ::brep::_optional_version vt;
+
+      if (composite_value_traits< ::brep::_version, id_pgsql >::get_null (
+            i.min_version_value))
+        wrapper_traits< ::brep::_optional_version >::set_null (vt);
+      else
+      {
+        ::brep::_version& vw =
+          wrapper_traits< ::brep::_optional_version >::set_ref (vt);
+
+        composite_value_traits< ::brep::_version, id_pgsql >::init (
+          vw,
+          i.min_version_value,
+          db);
+      }
+
+      // From common.hxx:75:12
+      v = (vt) ? bpkg::version ((vt)->epoch, std::move ((vt)->upstream), std::move ((vt)->release), (vt)->revision, 0) : brep::optional_version ();
+    }
+
+    // max_version
+    //
+    {
+      ::butl::optional< ::bpkg::version >& v =
+        o.max_version;
+
+      ::brep::_optional_version vt;
+
+      if (composite_value_traits< ::brep::_version, id_pgsql >::get_null (
+            i.max_version_value))
+        wrapper_traits< ::brep::_optional_version >::set_null (vt);
+      else
+      {
+        ::brep::_version& vw =
+          wrapper_traits< ::brep::_optional_version >::set_ref (vt);
+
+        composite_value_traits< ::brep::_version, id_pgsql >::init (
+          vw,
+          i.max_version_value,
+          db);
+      }
+
+      // From common.hxx:75:12
+      v = (vt) ? bpkg::version ((vt)->epoch, std::move ((vt)->upstream), std::move ((vt)->release), (vt)->revision, 0) : brep::optional_version ();
+    }
+
+    // min_open
+    //
+    {
+      bool& v =
+        o.min_open;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.min_open_value,
+        i.min_open_null);
+    }
+
+    // max_open
+    //
+    {
+      bool& v =
+        o.max_open;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.max_open_value,
+        i.max_open_null);
+    }
+  }
+
+  // requirement_alternatives
+  //
+
+  bool access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // conditional
+    //
+    t[0UL] = 0;
+
+    // buildtime
+    //
+    t[1UL] = 0;
+
+    // comment
+    //
+    if (t[2UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // conditional
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.conditional_value;
+    b[n].is_null = &i.conditional_null;
+    n++;
+
+    // buildtime
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.buildtime_value;
+    b[n].is_null = &i.buildtime_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // conditional
+    //
+    {
+      bool const& v =
+        o.conditional;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.conditional_value, is_null, v);
+      i.conditional_null = is_null;
+    }
+
+    // buildtime
+    //
+    {
+      bool const& v =
+        o.buildtime;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.buildtime_value, is_null, v);
+      i.buildtime_null = is_null;
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // conditional
+    //
+    {
+      bool& v =
+        o.conditional;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.conditional_value,
+        i.conditional_null);
+    }
+
+    // buildtime
+    //
+    {
+      bool& v =
+        o.buildtime;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.buildtime_value,
+        i.buildtime_null);
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // dependency
+  //
+
+  bool access::composite_value_traits< ::brep::dependency, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // constraint
+    //
+    if (composite_value_traits< ::bpkg::version_constraint, id_pgsql >::grow (
+          i.constraint_value, t + 1UL))
+      grew = true;
+
+    // package
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.package_value, t + 15UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::dependency, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.name_value.data ();
+    b[n].capacity = i.name_value.capacity ();
+    b[n].size = &i.name_size;
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // constraint
+    //
+    composite_value_traits< ::bpkg::version_constraint, id_pgsql >::bind (
+      b + n, i.constraint_value, sk);
+    n += 14UL;
+
+    // package
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.package_value, sk);
+    n += 6UL;
+  }
+
+  bool access::composite_value_traits< ::brep::dependency, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // name
+    //
+    {
+      ::bpkg::package_name const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.name_value.capacity ());
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_image (
+        i.name_value,
+        size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      i.name_size = size;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // constraint
+    //
+    {
+      ::butl::optional< ::bpkg::version_constraint > const& v =
+        o.constraint;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_null (v))
+        composite_value_traits< ::bpkg::version_constraint, id_pgsql >::set_null (
+          i.constraint_value, sk);
+      else
+      {
+        const::bpkg::version_constraint& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::version_constraint, id_pgsql >::init (
+              i.constraint_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // package
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::package > const& v =
+        o.package;
+
+      typedef object_traits< ::brep::package > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::package > > ptr_traits;
+
+      bool is_null (ptr_traits::null_ptr (v));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (v));
+
+        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+              i.package_value,
+              ptr_id,
+              sk))
+          grew = true;
+      }
+      else
+        composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.package_value, sk);
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::dependency, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::bpkg::package_name& v =
+        o.name;
+
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // constraint
+    //
+    {
+      ::butl::optional< ::bpkg::version_constraint >& v =
+        o.constraint;
+
+      if (composite_value_traits< ::bpkg::version_constraint, id_pgsql >::get_null (
+            i.constraint_value))
+        wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_null (v);
+      else
+      {
+        ::bpkg::version_constraint& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::version_constraint, id_pgsql >::init (
+          vw,
+          i.constraint_value,
+          db);
+      }
+    }
+
+    // package
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::package >& v =
+        o.package;
+
+      typedef object_traits< ::brep::package > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::package > > ptr_traits;
+
+      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
+            i.package_value))
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+          ptr_id,
+          i.package_value,
+          db);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<pgsql::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  // dependency_alternatives
+  //
+
+  bool access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // conditional
+    //
+    t[0UL] = 0;
+
+    // buildtime
+    //
+    t[1UL] = 0;
+
+    // comment
+    //
+    if (t[2UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // conditional
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.conditional_value;
+    b[n].is_null = &i.conditional_null;
+    n++;
+
+    // buildtime
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.buildtime_value;
+    b[n].is_null = &i.buildtime_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.comment_value.data ();
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].size = &i.comment_size;
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // conditional
+    //
+    {
+      bool const& v =
+        o.conditional;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.conditional_value, is_null, v);
+      i.conditional_null = is_null;
+    }
+
+    // buildtime
+    //
+    {
+      bool const& v =
+        o.buildtime;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.buildtime_value, is_null, v);
+      i.buildtime_null = is_null;
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.comment_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.comment_value,
+        size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      i.comment_size = size;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // conditional
+    //
+    {
+      bool& v =
+        o.conditional;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.conditional_value,
+        i.conditional_null);
+    }
+
+    // buildtime
+    //
+    {
+      bool& v =
+        o.buildtime;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.buildtime_value,
+        i.buildtime_null);
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // test_dependency
+  //
+
+  bool access::composite_value_traits< ::brep::test_dependency, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // dependency base
+    //
+    if (composite_value_traits< ::brep::dependency, id_pgsql >::grow (
+          i, t + 0UL))
+      grew = true;
+
+    // type
+    //
+    if (t[21UL])
+    {
+      i.type_value.capacity (i.type_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::test_dependency, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // dependency base
+    //
+    composite_value_traits< ::brep::dependency, id_pgsql >::bind (b + n, i, sk);
+    n += 21UL;
+
+    // type
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.type_value.data ();
+    b[n].capacity = i.type_value.capacity ();
+    b[n].size = &i.type_size;
+    b[n].is_null = &i.type_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::test_dependency, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // dependency base
+    //
+    if (composite_value_traits< ::brep::dependency, id_pgsql >::init (i, o, sk))
+      grew = true;
+
+    // type
+    //
+    {
+      ::bpkg::test_dependency_type const& v =
+        o.type;
+
+      // From package.hxx:189:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.type_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.type_value,
+        size,
+        is_null,
+        vt);
+      i.type_null = is_null;
+      i.type_size = size;
+      grew = grew || (cap != i.type_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::test_dependency, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // dependency base
+    //
+    composite_value_traits< ::brep::dependency, id_pgsql >::init (o, i, db);
+
+    // type
+    //
+    {
+      ::bpkg::test_dependency_type& v =
+        o.type;
+
+      ::std::string vt;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.type_value,
+        i.type_size,
+        i.type_null);
+
+      // From package.hxx:189:14
+      v = brep::to_test_dependency_type (vt);
+    }
+  }
+
+  // certificate
+  //
+
+  bool access::composite_value_traits< ::brep::certificate, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // fingerprint
+    //
+    if (t[0UL])
+    {
+      i.fingerprint_value.capacity (i.fingerprint_size);
+      grew = true;
+    }
+
+    // name
+    //
+    if (t[1UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // organization
+    //
+    if (t[2UL])
+    {
+      i.organization_value.capacity (i.organization_size);
+      grew = true;
+    }
+
+    // email
+    //
+    if (t[3UL])
+    {
+      i.email_value.capacity (i.email_size);
+      grew = true;
+    }
+
+    // pem
+    //
+    if (t[4UL])
+    {
+      i.pem_value.capacity (i.pem_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::certificate, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // fingerprint
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.fingerprint_value.data ();
+    b[n].capacity = i.fingerprint_value.capacity ();
+    b[n].size = &i.fingerprint_size;
+    b[n].is_null = &i.fingerprint_null;
+    n++;
+
+    // name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.name_value.data ();
+    b[n].capacity = i.name_value.capacity ();
+    b[n].size = &i.name_size;
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // organization
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.organization_value.data ();
+    b[n].capacity = i.organization_value.capacity ();
+    b[n].size = &i.organization_size;
+    b[n].is_null = &i.organization_null;
+    n++;
+
+    // email
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.email_value.data ();
+    b[n].capacity = i.email_value.capacity ();
+    b[n].size = &i.email_size;
+    b[n].is_null = &i.email_null;
+    n++;
+
+    // pem
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.pem_value.data ();
+    b[n].capacity = i.pem_value.capacity ();
+    b[n].size = &i.pem_size;
+    b[n].is_null = &i.pem_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::certificate, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // fingerprint
+    //
+    {
+      ::std::string const& v =
+        o.fingerprint;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.fingerprint_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.fingerprint_value,
+        size,
+        is_null,
+        v);
+      i.fingerprint_null = is_null;
+      i.fingerprint_size = size;
+      grew = grew || (cap != i.fingerprint_value.capacity ());
+    }
+
+    // name
+    //
+    {
+      ::std::string const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.name_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.name_value,
+        size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      i.name_size = size;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // organization
+    //
+    {
+      ::std::string const& v =
+        o.organization;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.organization_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.organization_value,
+        size,
+        is_null,
+        v);
+      i.organization_null = is_null;
+      i.organization_size = size;
+      grew = grew || (cap != i.organization_value.capacity ());
+    }
+
+    // email
+    //
+    {
+      ::std::string const& v =
+        o.email;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.email_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.email_value,
+        size,
+        is_null,
+        v);
+      i.email_null = is_null;
+      i.email_size = size;
+      grew = grew || (cap != i.email_value.capacity ());
+    }
+
+    // pem
+    //
+    {
+      ::std::string const& v =
+        o.pem;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.pem_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.pem_value,
+        size,
+        is_null,
+        v);
+      i.pem_null = is_null;
+      i.pem_size = size;
+      grew = grew || (cap != i.pem_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::certificate, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // fingerprint
+    //
+    {
+      ::std::string& v =
+        o.fingerprint;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.fingerprint_value,
+        i.fingerprint_size,
+        i.fingerprint_null);
+    }
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // organization
+    //
+    {
+      ::std::string& v =
+        o.organization;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.organization_value,
+        i.organization_size,
+        i.organization_null);
+    }
+
+    // email
+    //
+    {
+      ::std::string& v =
+        o.email;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.email_value,
+        i.email_size,
+        i.email_null);
+    }
+
+    // pem
+    //
+    {
+      ::std::string& v =
+        o.pem;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.pem_value,
+        i.pem_size,
+        i.pem_null);
+    }
+  }
+
+  // tenant
+  //
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  persist_statement_name[] = "persist_brep_tenant";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  find_statement_name[] = "find_brep_tenant";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  update_statement_name[] = "update_brep_tenant";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  erase_statement_name[] = "erase_brep_tenant";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  query_statement_name[] = "query_brep_tenant";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_tenant";
+
+  const unsigned int access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::bool_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  update_statement_types[] =
+  {
+    pgsql::int8_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid
+  };
+
+  struct access::object_traits_impl< ::brep::tenant, id_pgsql >::extra_statement_cache_type
+  {
+    extra_statement_cache_type (
+      pgsql::connection&,
+      image_type&,
+      id_image_type&,
+      pgsql::binding&,
+      pgsql::binding&,
+      pgsql::native_binding&,
+      const unsigned int*)
+    {
+    }
+  };
+
+  access::object_traits_impl< ::brep::tenant, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        id,
+        i.id_value,
+        i.id_size,
+        i.id_null);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (t[0UL])
+    {
+      i.id_value.capacity (i.id_size);
+      grew = true;
+    }
+
+    // creation_timestamp
+    //
+    t[1UL] = 0;
+
+    // archived
+    //
+    t[2UL] = 0;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      b[n].type = pgsql::bind::text;
+      b[n].buffer = i.id_value.data ();
+      b[n].capacity = i.id_value.capacity ();
+      b[n].size = &i.id_size;
+      b[n].is_null = &i.id_null;
+      n++;
+    }
+
+    // creation_timestamp
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.creation_timestamp_value;
+    b[n].is_null = &i.creation_timestamp_null;
+    n++;
+
+    // archived
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.archived_value;
+    b[n].is_null = &i.archived_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.id_value.data ();
+    b[n].capacity = i.id_value.capacity ();
+    b[n].size = &i.id_size;
+    b[n].is_null = &i.id_null;
+  }
+
+  bool access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::std::string const& v =
+        o.id;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.id_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.id_value,
+        size,
+        is_null,
+        v);
+      i.id_null = is_null;
+      i.id_size = size;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    // creation_timestamp
+    //
+    {
+      ::butl::timestamp const& v =
+        o.creation_timestamp;
+
+      // From common.hxx:119:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_image (
+        i.creation_timestamp_value, is_null, vt);
+      i.creation_timestamp_null = is_null;
+    }
+
+    // archived
+    //
+    {
+      bool const& v =
+        o.archived;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.archived_value, is_null, v);
+      i.archived_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::std::string& v =
+        o.id;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.id_value,
+        i.id_size,
+        i.id_null);
+    }
+
+    // creation_timestamp
+    //
+    {
+      ::butl::timestamp& v =
+        o.creation_timestamp;
+
+      ::uint64_t vt;
+
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_value (
+        vt,
+        i.creation_timestamp_value,
+        i.creation_timestamp_null);
+
+      // From common.hxx:119:14
+      v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+
+    // archived
+    //
+    {
+      bool& v =
+        o.archived;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.archived_value,
+        i.archived_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    {
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.id_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.id_value,
+        size,
+        is_null,
+        id);
+      i.id_null = is_null;
+      i.id_size = size;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"tenant\" "
+  "(\"id\", "
+  "\"creation_timestamp\", "
+  "\"archived\") "
+  "VALUES "
+  "($1, $2, $3)";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"tenant\".\"id\", "
+  "\"tenant\".\"creation_timestamp\", "
+  "\"tenant\".\"archived\" "
+  "FROM \"tenant\" "
+  "WHERE \"tenant\".\"id\"=$1";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::update_statement[] =
+  "UPDATE \"tenant\" "
+  "SET "
+  "\"creation_timestamp\"=$1, "
+  "\"archived\"=$2 "
+  "WHERE \"id\"=$3";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"tenant\" "
+  "WHERE \"id\"=$1";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::query_statement[] =
+  "SELECT "
+  "\"tenant\".\"id\", "
+  "\"tenant\".\"creation_timestamp\", "
+  "\"tenant\".\"archived\" "
+  "FROM \"tenant\"";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"tenant\"";
+
+  const char access::object_traits_impl< ::brep::tenant, id_pgsql >::table_name[] =
+  "\"tenant\"";
+
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+    using pgsql::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    pgsql::transaction& tr (pgsql::transaction::current ());
+    pgsql::connection& conn (tr.connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::tenant, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  result< access::object_traits_impl< ::brep::tenant, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        false,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // tenant_id
+  //
+
+  const char access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  query_statement_name[] = "query_brep_tenant_id";
+
+  bool access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // value
+    //
+    if (t[0UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // value
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.value_value.data ();
+    b[n].capacity = i.value_value.capacity ();
+    b[n].size = &i.value_size;
+    b[n].is_null = &i.value_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // value
+    //
+    {
+      ::std::string& v =
+        o.value;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::tenant_id, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"id\" ");
+
+    r += "FROM \"tenant\"";
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::tenant_id, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::tenant_id, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // repository
+  //
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::
+  persist_statement_name[] = "persist_brep_repository";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::
+  find_statement_name[] = "find_brep_repository";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::
+  update_statement_name[] = "update_brep_repository";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::
+  erase_statement_name[] = "erase_brep_repository";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::
+  query_statement_name[] = "query_brep_repository";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_repository";
+
+  const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::int8_oid,
+    pgsql::bool_oid,
+    pgsql::bool_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >::
+  update_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::int8_oid,
+    pgsql::bool_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  struct access::object_traits_impl< ::brep::repository, id_pgsql >::extra_statement_cache_type
+  {
+    pgsql::container_statements_impl< complements_traits > complements;
+    pgsql::container_statements_impl< prerequisites_traits > prerequisites;
+
+    extra_statement_cache_type (
+      pgsql::connection& c,
+      image_type&,
+      id_image_type&,
+      pgsql::binding& id,
+      pgsql::binding&,
+      pgsql::native_binding& idn,
+      const unsigned int* idt)
+    : complements (c, id, idn, idt),
+      prerequisites (c, id, idn, idt)
+    {
+    }
+  };
+
+  // complements
+  //
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  select_name[] = "select_brep_repository_complements";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  insert_name[] = "insert_brep_repository_complements";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  delete_name[] = "delete_brep_repository_complements";
+
+  const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  select_statement[] =
+  "SELECT "
+  "\"repository_complements\".\"index\", "
+  "\"repository_complements\".\"complement_tenant\", "
+  "\"repository_complements\".\"complement_canonical_name\" "
+  "FROM \"repository_complements\" "
+  "WHERE \"repository_complements\".\"repository_tenant\"=$1 AND \"repository_complements\".\"repository_canonical_name\"=$2 ORDER BY \"repository_complements\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  insert_statement[] =
+  "INSERT INTO \"repository_complements\" "
+  "(\"repository_tenant\", "
+  "\"repository_canonical_name\", "
+  "\"index\", "
+  "\"complement_tenant\", "
+  "\"complement_canonical_name\") "
+  "VALUES "
+  "($1, $2, $3, $4, $5)";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  delete_statement[] =
+  "DELETE FROM \"repository_complements\" "
+  "WHERE \"repository_tenant\"=$1 AND \"repository_canonical_name\"=$2";
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > wptr_traits;
+      typedef odb::pointer_traits< wptr_traits::strong_pointer_type > ptr_traits;
+
+      wptr_traits::strong_pointer_type sp (wptr_traits::lock (v));
+      bool is_null (ptr_traits::null_ptr (sp));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (sp));
+
+        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+              i.value_value,
+              ptr_id,
+              sk))
+          grew = true;
+      }
+      else
+        throw null_pointer ();
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > ptr_traits;
+
+      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
+            i.value_value))
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+          ptr_id,
+          i.value_value,
+          db);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<pgsql::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // prerequisites
+  //
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  select_name[] = "select_brep_repository_prerequisites";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  insert_name[] = "insert_brep_repository_prerequisites";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  delete_name[] = "delete_brep_repository_prerequisites";
+
+  const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  select_statement[] =
+  "SELECT "
+  "\"repository_prerequisites\".\"index\", "
+  "\"repository_prerequisites\".\"prerequisite_tenant\", "
+  "\"repository_prerequisites\".\"prerequisite_canonical_name\" "
+  "FROM \"repository_prerequisites\" "
+  "WHERE \"repository_prerequisites\".\"repository_tenant\"=$1 AND \"repository_prerequisites\".\"repository_canonical_name\"=$2 ORDER BY \"repository_prerequisites\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  insert_statement[] =
+  "INSERT INTO \"repository_prerequisites\" "
+  "(\"repository_tenant\", "
+  "\"repository_canonical_name\", "
+  "\"index\", "
+  "\"prerequisite_tenant\", "
+  "\"prerequisite_canonical_name\") "
+  "VALUES "
+  "($1, $2, $3, $4, $5)";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  delete_statement[] =
+  "DELETE FROM \"repository_prerequisites\" "
+  "WHERE \"repository_tenant\"=$1 AND \"repository_canonical_name\"=$2";
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > wptr_traits;
+      typedef odb::pointer_traits< wptr_traits::strong_pointer_type > ptr_traits;
+
+      wptr_traits::strong_pointer_type sp (wptr_traits::lock (v));
+      bool is_null (ptr_traits::null_ptr (sp));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (sp));
+
+        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+              i.value_value,
+              ptr_id,
+              sk))
+          grew = true;
+      }
+      else
+        throw null_pointer ();
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > ptr_traits;
+
+      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
+            i.value_value))
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+          ptr_id,
+          i.value_value,
+          db);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<pgsql::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  access::object_traits_impl< ::brep::repository, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::repository, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+        id,
+        i.id_value,
+        db);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::repository, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // location
+    //
+    if (composite_value_traits< ::brep::_repository_location, id_pgsql >::grow (
+          i.location_value, t + 2UL))
+      grew = true;
+
+    // display_name
+    //
+    if (t[4UL])
+    {
+      i.display_name_value.capacity (i.display_name_size);
+      grew = true;
+    }
+
+    // priority
+    //
+    t[5UL] = 0;
+
+    // interface_url
+    //
+    if (t[6UL])
+    {
+      i.interface_url_value.capacity (i.interface_url_size);
+      grew = true;
+    }
+
+    // email
+    //
+    if (composite_value_traits< ::bpkg::email, id_pgsql >::grow (
+          i.email_value, t + 7UL))
+      grew = true;
+
+    // summary
+    //
+    if (t[9UL])
+    {
+      i.summary_value.capacity (i.summary_size);
+      grew = true;
+    }
+
+    // description
+    //
+    if (t[10UL])
+    {
+      i.description_value.capacity (i.description_size);
+      grew = true;
+    }
+
+    // cache_location
+    //
+    if (composite_value_traits< ::brep::_repository_location, id_pgsql >::grow (
+          i.cache_location_value, t + 11UL))
+      grew = true;
+
+    // certificate
+    //
+    if (composite_value_traits< ::brep::certificate, id_pgsql >::grow (
+          i.certificate_value, t + 13UL))
+      grew = true;
+
+    // packages_timestamp
+    //
+    t[18UL] = 0;
+
+    // repositories_timestamp
+    //
+    t[19UL] = 0;
+
+    // internal
+    //
+    t[20UL] = 0;
+
+    // buildable
+    //
+    t[21UL] = 0;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+        b + n, i.id_value, sk);
+      n += 2UL;
+    }
+
+    // location
+    //
+    composite_value_traits< ::brep::_repository_location, id_pgsql >::bind (
+      b + n, i.location_value, sk);
+    n += 2UL;
+
+    // display_name
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.display_name_value.data ();
+    b[n].capacity = i.display_name_value.capacity ();
+    b[n].size = &i.display_name_size;
+    b[n].is_null = &i.display_name_null;
+    n++;
+
+    // priority
+    //
+    b[n].type = pgsql::bind::integer;
+    b[n].buffer = &i.priority_value;
+    b[n].is_null = &i.priority_null;
+    n++;
+
+    // interface_url
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.interface_url_value.data ();
+    b[n].capacity = i.interface_url_value.capacity ();
+    b[n].size = &i.interface_url_size;
+    b[n].is_null = &i.interface_url_null;
+    n++;
+
+    // email
+    //
+    composite_value_traits< ::bpkg::email, id_pgsql >::bind (
+      b + n, i.email_value, sk);
+    n += 2UL;
+
+    // summary
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.summary_value.data ();
+    b[n].capacity = i.summary_value.capacity ();
+    b[n].size = &i.summary_size;
+    b[n].is_null = &i.summary_null;
+    n++;
+
+    // description
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.description_value.data ();
+    b[n].capacity = i.description_value.capacity ();
+    b[n].size = &i.description_size;
+    b[n].is_null = &i.description_null;
+    n++;
+
+    // cache_location
+    //
+    composite_value_traits< ::brep::_repository_location, id_pgsql >::bind (
+      b + n, i.cache_location_value, sk);
+    n += 2UL;
+
+    // certificate
+    //
+    composite_value_traits< ::brep::certificate, id_pgsql >::bind (
+      b + n, i.certificate_value, sk);
+    n += 5UL;
+
+    // packages_timestamp
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.packages_timestamp_value;
+    b[n].is_null = &i.packages_timestamp_null;
+    n++;
+
+    // repositories_timestamp
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.repositories_timestamp_value;
+    b[n].is_null = &i.repositories_timestamp_null;
+    n++;
+
+    // internal
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.internal_value;
+    b[n].is_null = &i.internal_null;
+    n++;
+
+    // buildable
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.buildable_value;
+    b[n].is_null = &i.buildable_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+  }
+
+  bool access::object_traits_impl< ::brep::repository, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::brep::repository_id const& v =
+        o.id;
+
+      if (composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+            i.id_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // location
+    //
+    {
+      ::bpkg::repository_location const& v =
+        o.location;
+
+      // From common.hxx:285:14
+      ::brep::_repository_location const& vt =
+        brep::_repository_location 
+      {
+         (v).url (), (v).empty () ? brep::repository_type::pkg : (v).type () 
+      };
+
+
+      if (composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
+            i.location_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    // display_name
+    //
+    {
+      ::std::string const& v =
+        o.display_name;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.display_name_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.display_name_value,
+        size,
+        is_null,
+        v);
+      i.display_name_null = is_null;
+      i.display_name_size = size;
+      grew = grew || (cap != i.display_name_value.capacity ());
+    }
+
+    // priority
+    //
+    {
+      ::uint16_t const& v =
+        o.priority;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_image (
+        i.priority_value, is_null, v);
+      i.priority_null = is_null;
+    }
+
+    // interface_url
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.interface_url;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.interface_url_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.interface_url_value,
+        size,
+        is_null,
+        v);
+      i.interface_url_null = is_null;
+      i.interface_url_size = size;
+      grew = grew || (cap != i.interface_url_value.capacity ());
+    }
+
+    // email
+    //
+    {
+      ::butl::optional< ::bpkg::email > const& v =
+        o.email;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v))
+        composite_value_traits< ::bpkg::email, id_pgsql >::set_null (
+          i.email_value, sk);
+      else
+      {
+        const::bpkg::email& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::email, id_pgsql >::init (
+              i.email_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // summary
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.summary;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.summary_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.summary_value,
+        size,
+        is_null,
+        v);
+      i.summary_null = is_null;
+      i.summary_size = size;
+      grew = grew || (cap != i.summary_value.capacity ());
+    }
+
+    // description
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.description;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.description_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.description_value,
+        size,
+        is_null,
+        v);
+      i.description_null = is_null;
+      i.description_size = size;
+      grew = grew || (cap != i.description_value.capacity ());
+    }
+
+    // cache_location
+    //
+    {
+      ::bpkg::repository_location const& v =
+        o.cache_location;
+
+      // From common.hxx:285:14
+      ::brep::_repository_location const& vt =
+        brep::_repository_location 
+      {
+         (v).url (), (v).empty () ? brep::repository_type::pkg : (v).type () 
+      };
+
+
+      if (composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
+            i.cache_location_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    // certificate
+    //
+    {
+      ::butl::optional< ::brep::certificate > const& v =
+        o.certificate;
+
+      if (wrapper_traits< ::butl::optional< ::brep::certificate > >::get_null (v))
+        composite_value_traits< ::brep::certificate, id_pgsql >::set_null (
+          i.certificate_value, sk);
+      else
+      {
+        const::brep::certificate& vw = 
+          wrapper_traits< ::butl::optional< ::brep::certificate > >::get_ref (v);
+
+        if (composite_value_traits< ::brep::certificate, id_pgsql >::init (
+              i.certificate_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // packages_timestamp
+    //
+    {
+      ::butl::timestamp const& v =
+        o.packages_timestamp;
+
+      // From common.hxx:119:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_image (
+        i.packages_timestamp_value, is_null, vt);
+      i.packages_timestamp_null = is_null;
+    }
+
+    // repositories_timestamp
+    //
+    {
+      ::butl::timestamp const& v =
+        o.repositories_timestamp;
+
+      // From common.hxx:119:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_image (
+        i.repositories_timestamp_value, is_null, vt);
+      i.repositories_timestamp_null = is_null;
+    }
+
+    // internal
+    //
+    {
+      bool const& v =
+        o.internal;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.internal_value, is_null, v);
+      i.internal_null = is_null;
+    }
+
+    // buildable
+    //
+    {
+      bool const& v =
+        o.buildable;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.buildable_value, is_null, v);
+      i.buildable_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::repository_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // location
+    //
+    {
+      // From package.hxx:335:7
+      ::bpkg::repository_location v;
+
+      ::brep::_repository_location vt;
+
+      composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
+        vt,
+        i.location_value,
+        db);
+
+      // From common.hxx:285:14
+      v = brep::repository_location (std::move ((vt).url), (vt).type);
+      // From package.hxx:335:7
+      o.location = std::move (v);
+      assert (o.canonical_name == o.location.canonical_name ());
+    }
+
+    // display_name
+    //
+    {
+      ::std::string& v =
+        o.display_name;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.display_name_value,
+        i.display_name_size,
+        i.display_name_null);
+    }
+
+    // priority
+    //
+    {
+      ::uint16_t& v =
+        o.priority;
+
+      pgsql::value_traits<
+          ::uint16_t,
+          pgsql::id_integer >::set_value (
+        v,
+        i.priority_value,
+        i.priority_null);
+    }
+
+    // interface_url
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.interface_url;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.interface_url_value,
+        i.interface_url_size,
+        i.interface_url_null);
+    }
+
+    // email
+    //
+    {
+      ::butl::optional< ::bpkg::email >& v =
+        o.email;
+
+      if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null (
+            i.email_value))
+        wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v);
+      else
+      {
+        ::bpkg::email& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::email, id_pgsql >::init (
+          vw,
+          i.email_value,
+          db);
+      }
+    }
+
+    // summary
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.summary;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.summary_value,
+        i.summary_size,
+        i.summary_null);
+    }
+
+    // description
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.description;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.description_value,
+        i.description_size,
+        i.description_null);
+    }
+
+    // cache_location
+    //
+    {
+      ::bpkg::repository_location& v =
+        o.cache_location;
+
+      ::brep::_repository_location vt;
+
+      composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
+        vt,
+        i.cache_location_value,
+        db);
+
+      // From common.hxx:285:14
+      v = brep::repository_location (std::move ((vt).url), (vt).type);
+    }
+
+    // certificate
+    //
+    {
+      ::butl::optional< ::brep::certificate >& v =
+        o.certificate;
+
+      if (composite_value_traits< ::brep::certificate, id_pgsql >::get_null (
+            i.certificate_value))
+        wrapper_traits< ::butl::optional< ::brep::certificate > >::set_null (v);
+      else
+      {
+        ::brep::certificate& vw =
+          wrapper_traits< ::butl::optional< ::brep::certificate > >::set_ref (v);
+
+        composite_value_traits< ::brep::certificate, id_pgsql >::init (
+          vw,
+          i.certificate_value,
+          db);
+      }
+    }
+
+    // packages_timestamp
+    //
+    {
+      ::butl::timestamp& v =
+        o.packages_timestamp;
+
+      ::uint64_t vt;
+
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_value (
+        vt,
+        i.packages_timestamp_value,
+        i.packages_timestamp_null);
+
+      // From common.hxx:119:14
+      v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+
+    // repositories_timestamp
+    //
+    {
+      ::butl::timestamp& v =
+        o.repositories_timestamp;
+
+      ::uint64_t vt;
+
+      pgsql::value_traits<
+          ::uint64_t,
+          pgsql::id_bigint >::set_value (
+        vt,
+        i.repositories_timestamp_value,
+        i.repositories_timestamp_null);
+
+      // From common.hxx:119:14
+      v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+
+    // internal
+    //
+    {
+      bool& v =
+        o.internal;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.internal_value,
+        i.internal_null);
+    }
+
+    // buildable
+    //
+    {
+      bool& v =
+        o.buildable;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.buildable_value,
+        i.buildable_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    {
+      if (composite_value_traits< ::brep::repository_id, id_pgsql >::init (
+            i.id_value,
+            id,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"repository\" "
+  "(\"tenant\", "
+  "\"canonical_name\", "
+  "\"location_url\", "
+  "\"location_type\", "
+  "\"display_name\", "
+  "\"priority\", "
+  "\"interface_url\", "
+  "\"email\", "
+  "\"email_comment\", "
+  "\"summary\", "
+  "\"description\", "
+  "\"cache_location_url\", "
+  "\"cache_location_type\", "
+  "\"certificate_fingerprint\", "
+  "\"certificate_name\", "
+  "\"certificate_organization\", "
+  "\"certificate_email\", "
+  "\"certificate_pem\", "
+  "\"packages_timestamp\", "
+  "\"repositories_timestamp\", "
+  "\"internal\", "
+  "\"buildable\") "
+  "VALUES "
+  "($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22)";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"repository\".\"tenant\", "
+  "\"repository\".\"canonical_name\", "
+  "\"repository\".\"location_url\", "
+  "\"repository\".\"location_type\", "
+  "\"repository\".\"display_name\", "
+  "\"repository\".\"priority\", "
+  "\"repository\".\"interface_url\", "
+  "\"repository\".\"email\", "
+  "\"repository\".\"email_comment\", "
+  "\"repository\".\"summary\", "
+  "\"repository\".\"description\", "
+  "\"repository\".\"cache_location_url\", "
+  "\"repository\".\"cache_location_type\", "
+  "\"repository\".\"certificate_fingerprint\", "
+  "\"repository\".\"certificate_name\", "
+  "\"repository\".\"certificate_organization\", "
+  "\"repository\".\"certificate_email\", "
+  "\"repository\".\"certificate_pem\", "
+  "\"repository\".\"packages_timestamp\", "
+  "\"repository\".\"repositories_timestamp\", "
+  "\"repository\".\"internal\", "
+  "\"repository\".\"buildable\" "
+  "FROM \"repository\" "
+  "WHERE \"repository\".\"tenant\"=$1 AND \"repository\".\"canonical_name\"=$2";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::update_statement[] =
+  "UPDATE \"repository\" "
+  "SET "
+  "\"location_url\"=$1, "
+  "\"location_type\"=$2, "
+  "\"display_name\"=$3, "
+  "\"priority\"=$4, "
+  "\"interface_url\"=$5, "
+  "\"email\"=$6, "
+  "\"email_comment\"=$7, "
+  "\"summary\"=$8, "
+  "\"description\"=$9, "
+  "\"cache_location_url\"=$10, "
+  "\"cache_location_type\"=$11, "
+  "\"certificate_fingerprint\"=$12, "
+  "\"certificate_name\"=$13, "
+  "\"certificate_organization\"=$14, "
+  "\"certificate_email\"=$15, "
+  "\"certificate_pem\"=$16, "
+  "\"packages_timestamp\"=$17, "
+  "\"repositories_timestamp\"=$18, "
+  "\"internal\"=$19, "
+  "\"buildable\"=$20 "
+  "WHERE \"tenant\"=$21 AND \"canonical_name\"=$22";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"repository\" "
+  "WHERE \"tenant\"=$1 AND \"canonical_name\"=$2";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::query_statement[] =
+  "SELECT "
+  "\"repository\".\"tenant\", "
+  "\"repository\".\"canonical_name\", "
+  "\"repository\".\"location_url\", "
+  "\"repository\".\"location_type\", "
+  "\"repository\".\"display_name\", "
+  "\"repository\".\"priority\", "
+  "\"repository\".\"interface_url\", "
+  "\"repository\".\"email\", "
+  "\"repository\".\"email_comment\", "
+  "\"repository\".\"summary\", "
+  "\"repository\".\"description\", "
+  "\"repository\".\"cache_location_url\", "
+  "\"repository\".\"cache_location_type\", "
+  "\"repository\".\"certificate_fingerprint\", "
+  "\"repository\".\"certificate_name\", "
+  "\"repository\".\"certificate_organization\", "
+  "\"repository\".\"certificate_email\", "
+  "\"repository\".\"certificate_pem\", "
+  "\"repository\".\"packages_timestamp\", "
+  "\"repository\".\"repositories_timestamp\", "
+  "\"repository\".\"internal\", "
+  "\"repository\".\"buildable\" "
+  "FROM \"repository\"";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"repository\"";
+
+  const char access::object_traits_impl< ::brep::repository, id_pgsql >::table_name[] =
+  "\"repository\"";
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v =
+        obj.complements;
+
+      complements_traits::persist (
+        v,
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v =
+        obj.prerequisites;
+
+      prerequisites_traits::persist (
+        v,
+        esc.prerequisites);
+    }
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+    using pgsql::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    pgsql::transaction& tr (pgsql::transaction::current ());
+    pgsql::connection& conn (tr.connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v =
+        obj.complements;
+
+      complements_traits::update (
+        v,
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v =
+        obj.prerequisites;
+
+      prerequisites_traits::update (
+        v,
+        esc.prerequisites);
+    }
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      complements_traits::erase (
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      prerequisites_traits::erase (
+        esc.prerequisites);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::repository, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::repository, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::repository, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::repository, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::repository, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > >& v =
+        obj.complements;
+
+      complements_traits::load (
+        v,
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > >& v =
+        obj.prerequisites;
+
+      prerequisites_traits::load (
+        v,
+        esc.prerequisites);
+    }
+  }
+
+  result< access::object_traits_impl< ::brep::repository, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::repository, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        false,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::repository, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::repository, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::repository, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // _license_key
+  //
+
+  bool access::composite_value_traits< ::brep::package::_license_key, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // outer
+    //
+    t[0UL] = 0;
+
+    // inner
+    //
+    t[1UL] = 0;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package::_license_key, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // outer
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.outer_value;
+    b[n].is_null = &i.outer_null;
+    n++;
+
+    // inner
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.inner_value;
+    b[n].is_null = &i.inner_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::package::_license_key, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // outer
+    //
+    {
+      ::brep::package::_licenses_type::key_type::outer_type const& v =
+        o.outer;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::brep::package::_licenses_type::key_type::outer_type,
+          pgsql::id_bigint >::set_image (
+        i.outer_value, is_null, v);
+      i.outer_null = is_null;
+    }
+
+    // inner
+    //
+    {
+      ::brep::package::_licenses_type::key_type::inner_type const& v =
+        o.inner;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::brep::package::_licenses_type::key_type::inner_type,
+          pgsql::id_bigint >::set_image (
+        i.inner_value, is_null, v);
+      i.inner_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package::_license_key, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // outer
+    //
+    {
+      ::brep::package::_licenses_type::key_type::outer_type& v =
+        o.outer;
+
+      pgsql::value_traits<
+          ::brep::package::_licenses_type::key_type::outer_type,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.outer_value,
+        i.outer_null);
+    }
+
+    // inner
+    //
+    {
+      ::brep::package::_licenses_type::key_type::inner_type& v =
+        o.inner;
+
+      pgsql::value_traits<
+          ::brep::package::_licenses_type::key_type::inner_type,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.inner_value,
+        i.inner_null);
+    }
+  }
+
+  // _dependency_key
+  //
+
+  bool access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // outer
+    //
+    t[0UL] = 0;
+
+    // inner
+    //
+    t[1UL] = 0;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // outer
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.outer_value;
+    b[n].is_null = &i.outer_null;
+    n++;
+
+    // inner
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.inner_value;
+    b[n].is_null = &i.inner_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // outer
+    //
+    {
+      ::brep::package::_dependency_key::outer_type const& v =
+        o.outer;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::brep::package::_dependency_key::outer_type,
+          pgsql::id_bigint >::set_image (
+        i.outer_value, is_null, v);
+      i.outer_null = is_null;
+    }
+
+    // inner
+    //
+    {
+      ::brep::package::_dependency_key::inner_type const& v =
+        o.inner;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::brep::package::_dependency_key::inner_type,
+          pgsql::id_bigint >::set_image (
+        i.inner_value, is_null, v);
+      i.inner_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // outer
+    //
+    {
+      ::brep::package::_dependency_key::outer_type& v =
+        o.outer;
+
+      pgsql::value_traits<
+          ::brep::package::_dependency_key::outer_type,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.outer_value,
+        i.outer_null);
+    }
+
+    // inner
+    //
+    {
+      ::brep::package::_dependency_key::inner_type& v =
+        o.inner;
+
+      pgsql::value_traits<
+          ::brep::package::_dependency_key::inner_type,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.inner_value,
+        i.inner_null);
+    }
+  }
+
+  // _requirement_key
+  //
+
+  bool access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // outer
+    //
+    t[0UL] = 0;
+
+    // inner
+    //
+    t[1UL] = 0;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // outer
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.outer_value;
+    b[n].is_null = &i.outer_null;
+    n++;
+
+    // inner
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.inner_value;
+    b[n].is_null = &i.inner_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >::
+  init (image_type& i,
+        const value_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // outer
+    //
+    {
+      ::brep::package::_requirement_key::outer_type const& v =
+        o.outer;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::brep::package::_requirement_key::outer_type,
+          pgsql::id_bigint >::set_image (
+        i.outer_value, is_null, v);
+      i.outer_null = is_null;
+    }
+
+    // inner
+    //
+    {
+      ::brep::package::_requirement_key::inner_type const& v =
+        o.inner;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          ::brep::package::_requirement_key::inner_type,
+          pgsql::id_bigint >::set_image (
+        i.inner_value, is_null, v);
+      i.inner_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // outer
+    //
+    {
+      ::brep::package::_requirement_key::outer_type& v =
+        o.outer;
+
+      pgsql::value_traits<
+          ::brep::package::_requirement_key::outer_type,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.outer_value,
+        i.outer_null);
+    }
+
+    // inner
+    //
+    {
+      ::brep::package::_requirement_key::inner_type& v =
+        o.inner;
+
+      pgsql::value_traits<
+          ::brep::package::_requirement_key::inner_type,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.inner_value,
+        i.inner_null);
+    }
+  }
+
+  // package
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::
+  persist_statement_name[] = "persist_brep_package";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::
+  find_statement_name[] = "find_brep_package";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::
+  update_statement_name[] = "update_brep_package";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::
+  erase_statement_name[] = "erase_brep_package";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::
+  query_statement_name[] = "query_brep_package";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::
+  erase_query_statement_name[] = "erase_query_brep_package";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::
+  persist_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::
+  find_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::
+  update_statement_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  const char alias_traits<  ::brep::repository,
+    id_pgsql,
+    access::object_traits_impl< ::brep::package, id_pgsql >::internal_repository_tag>::
+  table_name[] = "\"internal_repository\"";
+
+  struct access::object_traits_impl< ::brep::package, id_pgsql >::extra_statement_cache_type
+  {
+    pgsql::container_statements_impl< license_alternatives_traits > license_alternatives;
+    pgsql::container_statements_impl< licenses_traits > licenses;
+    pgsql::container_statements_impl< topics_traits > topics;
+    pgsql::container_statements_impl< keywords_traits > keywords;
+    pgsql::container_statements_impl< dependencies_traits > dependencies;
+    pgsql::container_statements_impl< dependency_alternatives_traits > dependency_alternatives;
+    pgsql::container_statements_impl< requirements_traits > requirements;
+    pgsql::container_statements_impl< requirement_alternatives_traits > requirement_alternatives;
+    pgsql::container_statements_impl< tests_traits > tests;
+    pgsql::container_statements_impl< builds_traits > builds;
+    pgsql::container_statements_impl< build_constraints_traits > build_constraints;
+    pgsql::container_statements_impl< other_repositories_traits > other_repositories;
+
+    pgsql::section_statements< ::brep::package, build_section_traits > build_section;
+
+    extra_statement_cache_type (
+      pgsql::connection& c,
+      image_type& im,
+      id_image_type& idim,
+      pgsql::binding& id,
+      pgsql::binding& idv,
+      pgsql::native_binding& idn,
+      const unsigned int* idt)
+    : license_alternatives (c, id, idn, idt),
+      licenses (c, id, idn, idt),
+      topics (c, id, idn, idt),
+      keywords (c, id, idn, idt),
+      dependencies (c, id, idn, idt),
+      dependency_alternatives (c, id, idn, idt),
+      requirements (c, id, idn, idt),
+      requirement_alternatives (c, id, idn, idt),
+      tests (c, id, idn, idt),
+      builds (c, id, idn, idt),
+      build_constraints (c, id, idn, idt),
+      other_repositories (c, id, idn, idt),
+      build_section (c, im, idim, id, idv, idn, idt)
+    {
+    }
+  };
+
+  // license_alternatives
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  select_name[] = "select_brep_package_license_alternatives";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  insert_name[] = "insert_brep_package_license_alternatives";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  delete_name[] = "delete_brep_package_license_alternatives";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_license_alternatives\".\"index\", "
+  "\"package_license_alternatives\".\"comment\" "
+  "FROM \"package_license_alternatives\" "
+  "WHERE \"package_license_alternatives\".\"tenant\"=$1 AND \"package_license_alternatives\".\"name\"=$2::CITEXT AND \"package_license_alternatives\".\"version_epoch\"=$3 AND \"package_license_alternatives\".\"version_canonical_upstream\"=$4 AND \"package_license_alternatives\".\"version_canonical_release\"=$5 AND \"package_license_alternatives\".\"version_revision\"=$6 ORDER BY \"package_license_alternatives\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_license_alternatives\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"comment\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_license_alternatives\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // licenses
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  select_name[] = "select_brep_package_licenses";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  insert_name[] = "insert_brep_package_licenses";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  delete_name[] = "delete_brep_package_licenses";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_licenses\".\"alternative_index\", "
+  "\"package_licenses\".\"index\", "
+  "\"package_licenses\".\"license\" "
+  "FROM \"package_licenses\" "
+  "WHERE \"package_licenses\".\"tenant\"=$1 AND \"package_licenses\".\"name\"=$2::CITEXT AND \"package_licenses\".\"version_epoch\"=$3 AND \"package_licenses\".\"version_canonical_upstream\"=$4 AND \"package_licenses\".\"version_canonical_release\"=$5 AND \"package_licenses\".\"version_revision\"=$6";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_licenses\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"alternative_index\", "
+  "\"index\", "
+  "\"license\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_licenses\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // key
+    //
+    composite_value_traits< key_type, id_pgsql >::bind (
+      b + n, d.key_value, sk);
+    n += 2UL;
+
+    // value
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = d.value_value.data ();
+    b[n].capacity = d.value_value.capacity ();
+    b[n].size = &d.value_size;
+    b[n].is_null = &d.value_null;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // key
+    //
+    if (composite_value_traits< key_type, id_pgsql >::grow (
+          i.key_value, t + 0UL))
+      grew = true;
+
+    // value
+    //
+    if (t[2UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  init (data_image_type& i,
+        const key_type* k,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // key
+    //
+    if (k != 0)
+    {
+      composite_value_traits< key_type, id_pgsql >::init (
+        i.key_value,
+        *k,
+        sk);
+    }
+
+    // value
+    //
+    {
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.value_value.capacity ());
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_image (
+        i.value_value,
+        size,
+        is_null,
+        v);
+      i.value_null = is_null;
+      i.value_size = size;
+      grew = grew || (cap != i.value_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  init (key_type& k,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // key
+    //
+    {
+      composite_value_traits< key_type, id_pgsql >::init (
+        k,
+        i.key_value,
+        db);
+    }
+
+    // value
+    //
+    {
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  insert (const key_type& k, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &k, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  select (key_type& k, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (k, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  // topics
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  select_name[] = "select_brep_package_topics";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  insert_name[] = "insert_brep_package_topics";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  delete_name[] = "delete_brep_package_topics";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_topics\".\"index\", "
+  "\"package_topics\".\"topic\" "
+  "FROM \"package_topics\" "
+  "WHERE \"package_topics\".\"tenant\"=$1 AND \"package_topics\".\"name\"=$2::CITEXT AND \"package_topics\".\"version_epoch\"=$3 AND \"package_topics\".\"version_canonical_upstream\"=$4 AND \"package_topics\".\"version_canonical_release\"=$5 AND \"package_topics\".\"version_revision\"=$6 ORDER BY \"package_topics\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_topics\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"topic\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_topics\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = d.value_value.data ();
+    b[n].capacity = d.value_value.capacity ();
+    b[n].size = &d.value_size;
+    b[n].is_null = &d.value_null;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (t[1UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.value_value.capacity ());
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_image (
+        i.value_value,
+        size,
+        is_null,
+        v);
+      i.value_null = is_null;
+      i.value_size = size;
+      grew = grew || (cap != i.value_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // keywords
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  select_name[] = "select_brep_package_keywords";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  insert_name[] = "insert_brep_package_keywords";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  delete_name[] = "delete_brep_package_keywords";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_keywords\".\"index\", "
+  "\"package_keywords\".\"keyword\" "
+  "FROM \"package_keywords\" "
+  "WHERE \"package_keywords\".\"tenant\"=$1 AND \"package_keywords\".\"name\"=$2::CITEXT AND \"package_keywords\".\"version_epoch\"=$3 AND \"package_keywords\".\"version_canonical_upstream\"=$4 AND \"package_keywords\".\"version_canonical_release\"=$5 AND \"package_keywords\".\"version_revision\"=$6 ORDER BY \"package_keywords\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_keywords\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"keyword\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_keywords\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = d.value_value.data ();
+    b[n].capacity = d.value_value.capacity ();
+    b[n].size = &d.value_size;
+    b[n].is_null = &d.value_null;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (t[1UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.value_value.capacity ());
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_image (
+        i.value_value,
+        size,
+        is_null,
+        v);
+      i.value_null = is_null;
+      i.value_size = size;
+      grew = grew || (cap != i.value_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // dependencies
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  select_name[] = "select_brep_package_dependencies";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  insert_name[] = "insert_brep_package_dependencies";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  delete_name[] = "delete_brep_package_dependencies";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::bool_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_dependencies\".\"index\", "
+  "\"package_dependencies\".\"conditional\", "
+  "\"package_dependencies\".\"buildtime\", "
+  "\"package_dependencies\".\"comment\" "
+  "FROM \"package_dependencies\" "
+  "WHERE \"package_dependencies\".\"tenant\"=$1 AND \"package_dependencies\".\"name\"=$2::CITEXT AND \"package_dependencies\".\"version_epoch\"=$3 AND \"package_dependencies\".\"version_canonical_upstream\"=$4 AND \"package_dependencies\".\"version_canonical_release\"=$5 AND \"package_dependencies\".\"version_revision\"=$6 ORDER BY \"package_dependencies\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_dependencies\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"conditional\", "
+  "\"buildtime\", "
+  "\"comment\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_dependencies\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // dependency_alternatives
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  select_name[] = "select_brep_package_dependency_alternatives";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  insert_name[] = "insert_brep_package_dependency_alternatives";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  delete_name[] = "delete_brep_package_dependency_alternatives";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::bool_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_dependency_alternatives\".\"dependency_index\", "
+  "\"package_dependency_alternatives\".\"index\", "
+  "\"package_dependency_alternatives\".\"dep_name\"::TEXT, "
+  "\"package_dependency_alternatives\".\"dep_min_version_epoch\", "
+  "\"package_dependency_alternatives\".\"dep_min_version_canonical_upstream\", "
+  "\"package_dependency_alternatives\".\"dep_min_version_canonical_release\", "
+  "\"package_dependency_alternatives\".\"dep_min_version_revision\", "
+  "\"package_dependency_alternatives\".\"dep_min_version_upstream\", "
+  "\"package_dependency_alternatives\".\"dep_min_version_release\", "
+  "\"package_dependency_alternatives\".\"dep_max_version_epoch\", "
+  "\"package_dependency_alternatives\".\"dep_max_version_canonical_upstream\", "
+  "\"package_dependency_alternatives\".\"dep_max_version_canonical_release\", "
+  "\"package_dependency_alternatives\".\"dep_max_version_revision\", "
+  "\"package_dependency_alternatives\".\"dep_max_version_upstream\", "
+  "\"package_dependency_alternatives\".\"dep_max_version_release\", "
+  "\"package_dependency_alternatives\".\"dep_min_open\", "
+  "\"package_dependency_alternatives\".\"dep_max_open\", "
+  "\"package_dependency_alternatives\".\"dep_package_tenant\", "
+  "\"package_dependency_alternatives\".\"dep_package_name\"::TEXT, "
+  "\"package_dependency_alternatives\".\"dep_package_version_epoch\", "
+  "\"package_dependency_alternatives\".\"dep_package_version_canonical_upstream\", "
+  "\"package_dependency_alternatives\".\"dep_package_version_canonical_release\", "
+  "\"package_dependency_alternatives\".\"dep_package_version_revision\" "
+  "FROM \"package_dependency_alternatives\" "
+  "WHERE \"package_dependency_alternatives\".\"tenant\"=$1 AND \"package_dependency_alternatives\".\"name\"=$2::CITEXT AND \"package_dependency_alternatives\".\"version_epoch\"=$3 AND \"package_dependency_alternatives\".\"version_canonical_upstream\"=$4 AND \"package_dependency_alternatives\".\"version_canonical_release\"=$5 AND \"package_dependency_alternatives\".\"version_revision\"=$6";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_dependency_alternatives\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"dependency_index\", "
+  "\"index\", "
+  "\"dep_name\", "
+  "\"dep_min_version_epoch\", "
+  "\"dep_min_version_canonical_upstream\", "
+  "\"dep_min_version_canonical_release\", "
+  "\"dep_min_version_revision\", "
+  "\"dep_min_version_upstream\", "
+  "\"dep_min_version_release\", "
+  "\"dep_max_version_epoch\", "
+  "\"dep_max_version_canonical_upstream\", "
+  "\"dep_max_version_canonical_release\", "
+  "\"dep_max_version_revision\", "
+  "\"dep_max_version_upstream\", "
+  "\"dep_max_version_release\", "
+  "\"dep_min_open\", "
+  "\"dep_max_open\", "
+  "\"dep_package_tenant\", "
+  "\"dep_package_name\", "
+  "\"dep_package_version_epoch\", "
+  "\"dep_package_version_canonical_upstream\", "
+  "\"dep_package_version_canonical_release\", "
+  "\"dep_package_version_revision\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9::CITEXT, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25::CITEXT, $26, $27, $28, $29)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_dependency_alternatives\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // key
+    //
+    composite_value_traits< key_type, id_pgsql >::bind (
+      b + n, d.key_value, sk);
+    n += 2UL;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // key
+    //
+    if (composite_value_traits< key_type, id_pgsql >::grow (
+          i.key_value, t + 0UL))
+      grew = true;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 2UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  init (data_image_type& i,
+        const key_type* k,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // key
+    //
+    if (k != 0)
+    {
+      composite_value_traits< key_type, id_pgsql >::init (
+        i.key_value,
+        *k,
+        sk);
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  init (key_type& k,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // key
+    //
+    {
+      composite_value_traits< key_type, id_pgsql >::init (
+        k,
+        i.key_value,
+        db);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  insert (const key_type& k, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &k, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  select (key_type& k, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (k, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  // requirements
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  select_name[] = "select_brep_package_requirements";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  insert_name[] = "insert_brep_package_requirements";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  delete_name[] = "delete_brep_package_requirements";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::bool_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_requirements\".\"index\", "
+  "\"package_requirements\".\"conditional\", "
+  "\"package_requirements\".\"buildtime\", "
+  "\"package_requirements\".\"comment\" "
+  "FROM \"package_requirements\" "
+  "WHERE \"package_requirements\".\"tenant\"=$1 AND \"package_requirements\".\"name\"=$2::CITEXT AND \"package_requirements\".\"version_epoch\"=$3 AND \"package_requirements\".\"version_canonical_upstream\"=$4 AND \"package_requirements\".\"version_canonical_release\"=$5 AND \"package_requirements\".\"version_revision\"=$6 ORDER BY \"package_requirements\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_requirements\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"conditional\", "
+  "\"buildtime\", "
+  "\"comment\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_requirements\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // requirement_alternatives
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  select_name[] = "select_brep_package_requirement_alternatives";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  insert_name[] = "insert_brep_package_requirement_alternatives";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  delete_name[] = "delete_brep_package_requirement_alternatives";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_requirement_alternatives\".\"requirement_index\", "
+  "\"package_requirement_alternatives\".\"index\", "
+  "\"package_requirement_alternatives\".\"id\" "
+  "FROM \"package_requirement_alternatives\" "
+  "WHERE \"package_requirement_alternatives\".\"tenant\"=$1 AND \"package_requirement_alternatives\".\"name\"=$2::CITEXT AND \"package_requirement_alternatives\".\"version_epoch\"=$3 AND \"package_requirement_alternatives\".\"version_canonical_upstream\"=$4 AND \"package_requirement_alternatives\".\"version_canonical_release\"=$5 AND \"package_requirement_alternatives\".\"version_revision\"=$6";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_requirement_alternatives\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"requirement_index\", "
+  "\"index\", "
+  "\"id\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_requirement_alternatives\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // key
+    //
+    composite_value_traits< key_type, id_pgsql >::bind (
+      b + n, d.key_value, sk);
+    n += 2UL;
+
+    // value
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = d.value_value.data ();
+    b[n].capacity = d.value_value.capacity ();
+    b[n].size = &d.value_size;
+    b[n].is_null = &d.value_null;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // key
+    //
+    if (composite_value_traits< key_type, id_pgsql >::grow (
+          i.key_value, t + 0UL))
+      grew = true;
+
+    // value
+    //
+    if (t[2UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  init (data_image_type& i,
+        const key_type* k,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // key
+    //
+    if (k != 0)
+    {
+      composite_value_traits< key_type, id_pgsql >::init (
+        i.key_value,
+        *k,
+        sk);
+    }
+
+    // value
+    //
+    {
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.value_value.capacity ());
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_image (
+        i.value_value,
+        size,
+        is_null,
+        v);
+      i.value_null = is_null;
+      i.value_size = size;
+      grew = grew || (cap != i.value_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  init (key_type& k,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // key
+    //
+    {
+      composite_value_traits< key_type, id_pgsql >::init (
+        k,
+        i.key_value,
+        db);
+    }
+
+    // value
+    //
+    {
+      pgsql::value_traits<
+          value_type,
+          pgsql::id_string >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  insert (const key_type& k, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &k, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  select (key_type& k, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (k, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  // tests
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  select_name[] = "select_brep_package_tests";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  insert_name[] = "insert_brep_package_tests";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  delete_name[] = "delete_brep_package_tests";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::bool_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_tests\".\"index\", "
+  "\"package_tests\".\"test_name\"::TEXT, "
+  "\"package_tests\".\"test_min_version_epoch\", "
+  "\"package_tests\".\"test_min_version_canonical_upstream\", "
+  "\"package_tests\".\"test_min_version_canonical_release\", "
+  "\"package_tests\".\"test_min_version_revision\", "
+  "\"package_tests\".\"test_min_version_upstream\", "
+  "\"package_tests\".\"test_min_version_release\", "
+  "\"package_tests\".\"test_max_version_epoch\", "
+  "\"package_tests\".\"test_max_version_canonical_upstream\", "
+  "\"package_tests\".\"test_max_version_canonical_release\", "
+  "\"package_tests\".\"test_max_version_revision\", "
+  "\"package_tests\".\"test_max_version_upstream\", "
+  "\"package_tests\".\"test_max_version_release\", "
+  "\"package_tests\".\"test_min_open\", "
+  "\"package_tests\".\"test_max_open\", "
+  "\"package_tests\".\"test_package_tenant\", "
+  "\"package_tests\".\"test_package_name\"::TEXT, "
+  "\"package_tests\".\"test_package_version_epoch\", "
+  "\"package_tests\".\"test_package_version_canonical_upstream\", "
+  "\"package_tests\".\"test_package_version_canonical_release\", "
+  "\"package_tests\".\"test_package_version_revision\", "
+  "\"package_tests\".\"test_type\" "
+  "FROM \"package_tests\" "
+  "WHERE \"package_tests\".\"tenant\"=$1 AND \"package_tests\".\"name\"=$2::CITEXT AND \"package_tests\".\"version_epoch\"=$3 AND \"package_tests\".\"version_canonical_upstream\"=$4 AND \"package_tests\".\"version_canonical_release\"=$5 AND \"package_tests\".\"version_revision\"=$6 ORDER BY \"package_tests\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_tests\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"test_name\", "
+  "\"test_min_version_epoch\", "
+  "\"test_min_version_canonical_upstream\", "
+  "\"test_min_version_canonical_release\", "
+  "\"test_min_version_revision\", "
+  "\"test_min_version_upstream\", "
+  "\"test_min_version_release\", "
+  "\"test_max_version_epoch\", "
+  "\"test_max_version_canonical_upstream\", "
+  "\"test_max_version_canonical_release\", "
+  "\"test_max_version_revision\", "
+  "\"test_max_version_upstream\", "
+  "\"test_max_version_release\", "
+  "\"test_min_open\", "
+  "\"test_max_open\", "
+  "\"test_package_tenant\", "
+  "\"test_package_name\", "
+  "\"test_package_version_epoch\", "
+  "\"test_package_version_canonical_upstream\", "
+  "\"test_package_version_canonical_release\", "
+  "\"test_package_version_revision\", "
+  "\"test_type\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8::CITEXT, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24::CITEXT, $25, $26, $27, $28, $29)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_tests\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // builds
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  select_name[] = "select_brep_package_builds";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  insert_name[] = "insert_brep_package_builds";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  delete_name[] = "delete_brep_package_builds";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_builds\".\"index\", "
+  "\"package_builds\".\"expression\", "
+  "\"package_builds\".\"comment\" "
+  "FROM \"package_builds\" "
+  "WHERE \"package_builds\".\"tenant\"=$1 AND \"package_builds\".\"name\"=$2::CITEXT AND \"package_builds\".\"version_epoch\"=$3 AND \"package_builds\".\"version_canonical_upstream\"=$4 AND \"package_builds\".\"version_canonical_release\"=$5 AND \"package_builds\".\"version_revision\"=$6 ORDER BY \"package_builds\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_builds\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"expression\", "
+  "\"comment\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_builds\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // build_constraints
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  select_name[] = "select_brep_package_build_constraints";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  insert_name[] = "insert_brep_package_build_constraints";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  delete_name[] = "delete_brep_package_build_constraints";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::bool_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_build_constraints\".\"index\", "
+  "\"package_build_constraints\".\"exclusion\", "
+  "\"package_build_constraints\".\"config\", "
+  "\"package_build_constraints\".\"target\", "
+  "\"package_build_constraints\".\"comment\" "
+  "FROM \"package_build_constraints\" "
+  "WHERE \"package_build_constraints\".\"tenant\"=$1 AND \"package_build_constraints\".\"name\"=$2::CITEXT AND \"package_build_constraints\".\"version_epoch\"=$3 AND \"package_build_constraints\".\"version_canonical_upstream\"=$4 AND \"package_build_constraints\".\"version_canonical_release\"=$5 AND \"package_build_constraints\".\"version_revision\"=$6 ORDER BY \"package_build_constraints\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_build_constraints\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"exclusion\", "
+  "\"config\", "
+  "\"target\", "
+  "\"comment\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_build_constraints\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_pgsql >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_pgsql >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // other_repositories
+  //
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  select_name[] = "select_brep_package_other_repositories";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  insert_name[] = "insert_brep_package_other_repositories";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  delete_name[] = "delete_brep_package_other_repositories";
+
+  const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  insert_types[] =
+  {
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::text_oid,
+    pgsql::text_oid,
+    pgsql::int4_oid,
+    pgsql::int8_oid,
+    pgsql::text_oid,
+    pgsql::text_oid
+  };
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  select_statement[] =
+  "SELECT "
+  "\"package_other_repositories\".\"index\", "
+  "\"package_other_repositories\".\"repository_tenant\", "
+  "\"package_other_repositories\".\"repository_canonical_name\" "
+  "FROM \"package_other_repositories\" "
+  "WHERE \"package_other_repositories\".\"tenant\"=$1 AND \"package_other_repositories\".\"name\"=$2::CITEXT AND \"package_other_repositories\".\"version_epoch\"=$3 AND \"package_other_repositories\".\"version_canonical_upstream\"=$4 AND \"package_other_repositories\".\"version_canonical_release\"=$5 AND \"package_other_repositories\".\"version_revision\"=$6 ORDER BY \"package_other_repositories\".\"index\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  insert_statement[] =
+  "INSERT INTO \"package_other_repositories\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"index\", "
+  "\"repository_tenant\", "
+  "\"repository_canonical_name\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  delete_statement[] =
+  "DELETE FROM \"package_other_repositories\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  bind (pgsql::bind* b,
+        const pgsql::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = 0;
+
+    // value
+    //
+    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace pgsql;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_image (
+        i.index_value, is_null, *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > ptr_traits;
+
+      bool is_null (ptr_traits::null_ptr (v));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (v));
+
+        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+              i.value_value,
+              ptr_id,
+              sk))
+          grew = true;
+      }
+      else
+        throw null_pointer ();
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      pgsql::value_traits<
+          index_type,
+          pgsql::id_bigint >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > ptr_traits;
+
+      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
+            i.value_value))
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+          ptr_id,
+          i.value_value,
+          db);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<pgsql::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  delete_ (void* d)
+  {
+    using namespace pgsql;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace pgsql;
+    using pgsql::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits::
+  erase (statements_type& sts)
+  {
+    using namespace pgsql;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // build_section
+  //
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_section_traits::
+  load (extra_statement_cache_type& esc, object_type& obj)
+  {
+    // builds
+    //
+    {
+      ::brep::build_class_exprs& v =
+        obj.builds;
+
+      builds_traits::load (
+        v,
+        esc.builds);
+    }
+
+    // build_constraints
+    //
+    {
+      ::brep::package::build_constraints_type& v =
+        obj.build_constraints;
+
+      build_constraints_traits::load (
+        v,
+        esc.build_constraints);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::build_section_traits::
+  update (extra_statement_cache_type& esc, const object_type& obj)
+  {
+    // builds
+    //
+    {
+      ::brep::build_class_exprs const& v =
+        obj.builds;
+
+      builds_traits::update (
+        v,
+        esc.builds);
+    }
+
+    // build_constraints
+    //
+    {
+      ::brep::package::build_constraints_type const& v =
+        obj.build_constraints;
+
+      build_constraints_traits::update (
+        v,
+        esc.build_constraints);
+    }
+  }
+
+  access::object_traits_impl< ::brep::package, id_pgsql >::id_type
+  access::object_traits_impl< ::brep::package, id_pgsql >::
+  id (const image_type& i)
+  {
+    pgsql::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        id,
+        i.id_value,
+        db);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // version
+    //
+    if (composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::grow (
+          i.version_value, t + 6UL))
+      grew = true;
+
+    // upstream_version
+    //
+    if (t[8UL])
+    {
+      i.upstream_version_value.capacity (i.upstream_version_size);
+      grew = true;
+    }
+
+    // project
+    //
+    if (t[9UL])
+    {
+      i.project_value.capacity (i.project_size);
+      grew = true;
+    }
+
+    // priority
+    //
+    if (composite_value_traits< ::brep::package::priority_type, id_pgsql >::grow (
+          i.priority_value, t + 10UL))
+      grew = true;
+
+    // summary
+    //
+    if (t[12UL])
+    {
+      i.summary_value.capacity (i.summary_size);
+      grew = true;
+    }
+
+    // description
+    //
+    if (t[13UL])
+    {
+      i.description_value.capacity (i.description_size);
+      grew = true;
+    }
+
+    // description_type
+    //
+    if (t[14UL])
+    {
+      i.description_type_value.capacity (i.description_type_size);
+      grew = true;
+    }
+
+    // changes
+    //
+    if (t[15UL])
+    {
+      i.changes_value.capacity (i.changes_size);
+      grew = true;
+    }
+
+    // url
+    //
+    if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow (
+          i.url_value, t + 16UL))
+      grew = true;
+
+    // doc_url
+    //
+    if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow (
+          i.doc_url_value, t + 18UL))
+      grew = true;
+
+    // src_url
+    //
+    if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow (
+          i.src_url_value, t + 20UL))
+      grew = true;
+
+    // package_url
+    //
+    if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow (
+          i.package_url_value, t + 22UL))
+      grew = true;
+
+    // email
+    //
+    if (composite_value_traits< ::bpkg::email, id_pgsql >::grow (
+          i.email_value, t + 24UL))
+      grew = true;
+
+    // package_email
+    //
+    if (composite_value_traits< ::bpkg::email, id_pgsql >::grow (
+          i.package_email_value, t + 26UL))
+      grew = true;
+
+    // build_email
+    //
+    if (composite_value_traits< ::bpkg::email, id_pgsql >::grow (
+          i.build_email_value, t + 28UL))
+      grew = true;
+
+    // build_warning_email
+    //
+    if (composite_value_traits< ::bpkg::email, id_pgsql >::grow (
+          i.build_warning_email_value, t + 30UL))
+      grew = true;
+
+    // build_error_email
+    //
+    if (composite_value_traits< ::bpkg::email, id_pgsql >::grow (
+          i.build_error_email_value, t + 32UL))
+      grew = true;
+
+    // internal_repository
+    //
+    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
+          i.internal_repository_value, t + 34UL))
+      grew = true;
+
+    // location
+    //
+    if (t[36UL])
+    {
+      i.location_value.capacity (i.location_size);
+      grew = true;
+    }
+
+    // fragment
+    //
+    if (t[37UL])
+    {
+      i.fragment_value.capacity (i.fragment_size);
+      grew = true;
+    }
+
+    // sha256sum
+    //
+    if (t[38UL])
+    {
+      i.sha256sum_value.capacity (i.sha256sum_size);
+      grew = true;
+    }
+
+    // buildable
+    //
+    t[39UL] = 0;
+
+    // unbuildable_reason
+    //
+    if (t[40UL])
+    {
+      i.unbuildable_reason_value.capacity (i.unbuildable_reason_size);
+      grew = true;
+    }
+
+    // search_index
+    //
+    if (t[41UL])
+    {
+      i.search_index_value.capacity (i.search_index_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+        b + n, i.id_value, sk);
+      n += 6UL;
+    }
+
+    // version
+    //
+    composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::bind (
+      b + n, i.version_value, sk);
+    n += 2UL;
+
+    // upstream_version
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.upstream_version_value.data ();
+    b[n].capacity = i.upstream_version_value.capacity ();
+    b[n].size = &i.upstream_version_size;
+    b[n].is_null = &i.upstream_version_null;
+    n++;
+
+    // project
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.project_value.data ();
+    b[n].capacity = i.project_value.capacity ();
+    b[n].size = &i.project_size;
+    b[n].is_null = &i.project_null;
+    n++;
+
+    // priority
+    //
+    composite_value_traits< ::brep::package::priority_type, id_pgsql >::bind (
+      b + n, i.priority_value, sk);
+    n += 2UL;
+
+    // summary
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.summary_value.data ();
+    b[n].capacity = i.summary_value.capacity ();
+    b[n].size = &i.summary_size;
+    b[n].is_null = &i.summary_null;
+    n++;
+
+    // description
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.description_value.data ();
+    b[n].capacity = i.description_value.capacity ();
+    b[n].size = &i.description_size;
+    b[n].is_null = &i.description_null;
+    n++;
+
+    // description_type
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.description_type_value.data ();
+    b[n].capacity = i.description_type_value.capacity ();
+    b[n].size = &i.description_type_size;
+    b[n].is_null = &i.description_type_null;
+    n++;
+
+    // changes
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.changes_value.data ();
+    b[n].capacity = i.changes_value.capacity ();
+    b[n].size = &i.changes_size;
+    b[n].is_null = &i.changes_null;
+    n++;
+
+    // url
+    //
+    composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind (
+      b + n, i.url_value, sk);
+    n += 2UL;
+
+    // doc_url
+    //
+    composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind (
+      b + n, i.doc_url_value, sk);
+    n += 2UL;
+
+    // src_url
+    //
+    composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind (
+      b + n, i.src_url_value, sk);
+    n += 2UL;
+
+    // package_url
+    //
+    composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind (
+      b + n, i.package_url_value, sk);
+    n += 2UL;
+
+    // email
+    //
+    composite_value_traits< ::bpkg::email, id_pgsql >::bind (
+      b + n, i.email_value, sk);
+    n += 2UL;
+
+    // package_email
+    //
+    composite_value_traits< ::bpkg::email, id_pgsql >::bind (
+      b + n, i.package_email_value, sk);
+    n += 2UL;
+
+    // build_email
+    //
+    composite_value_traits< ::bpkg::email, id_pgsql >::bind (
+      b + n, i.build_email_value, sk);
+    n += 2UL;
+
+    // build_warning_email
+    //
+    composite_value_traits< ::bpkg::email, id_pgsql >::bind (
+      b + n, i.build_warning_email_value, sk);
+    n += 2UL;
+
+    // build_error_email
+    //
+    composite_value_traits< ::bpkg::email, id_pgsql >::bind (
+      b + n, i.build_error_email_value, sk);
+    n += 2UL;
+
+    // internal_repository
+    //
+    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
+      b + n, i.internal_repository_value, sk);
+    n += 2UL;
+
+    // location
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.location_value.data ();
+    b[n].capacity = i.location_value.capacity ();
+    b[n].size = &i.location_size;
+    b[n].is_null = &i.location_null;
+    n++;
+
+    // fragment
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.fragment_value.data ();
+    b[n].capacity = i.fragment_value.capacity ();
+    b[n].size = &i.fragment_size;
+    b[n].is_null = &i.fragment_null;
+    n++;
+
+    // sha256sum
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.sha256sum_value.data ();
+    b[n].capacity = i.sha256sum_value.capacity ();
+    b[n].size = &i.sha256sum_size;
+    b[n].is_null = &i.sha256sum_null;
+    n++;
+
+    // buildable
+    //
+    b[n].type = pgsql::bind::boolean_;
+    b[n].buffer = &i.buildable_value;
+    b[n].is_null = &i.buildable_null;
+    n++;
+
+    // unbuildable_reason
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.unbuildable_reason_value.data ();
+    b[n].capacity = i.unbuildable_reason_value.capacity ();
+    b[n].size = &i.unbuildable_reason_size;
+    b[n].is_null = &i.unbuildable_reason_null;
+    n++;
+
+    // search_index
+    //
+    b[n].type = pgsql::bind::text;
+    b[n].buffer = i.search_index_value.data ();
+    b[n].capacity = i.search_index_value.capacity ();
+    b[n].size = &i.search_index_size;
+    b[n].is_null = &i.search_index_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  bind (pgsql::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::
+  init (image_type& i,
+        const object_type& o,
+        pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::brep::package_id const& v =
+        o.id;
+
+      if (composite_value_traits< ::brep::package_id, id_pgsql >::init (
+            i.id_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // version
+    //
+    {
+      ::brep::package::upstream_version_type const& v =
+        o.version;
+
+      if (composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::init (
+            i.version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // upstream_version
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.upstream_version;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.upstream_version_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.upstream_version_value,
+        size,
+        is_null,
+        v);
+      i.upstream_version_null = is_null;
+      i.upstream_version_size = size;
+      grew = grew || (cap != i.upstream_version_value.capacity ());
+    }
+
+    // project
+    //
+    {
+      ::bpkg::package_name const& v =
+        o.project;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.project_value.capacity ());
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_image (
+        i.project_value,
+        size,
+        is_null,
+        v);
+      i.project_null = is_null;
+      i.project_size = size;
+      grew = grew || (cap != i.project_value.capacity ());
+    }
+
+    // priority
+    //
+    {
+      ::brep::package::priority_type const& v =
+        o.priority;
+
+      if (composite_value_traits< ::brep::package::priority_type, id_pgsql >::init (
+            i.priority_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // summary
+    //
+    {
+      ::std::string const& v =
+        o.summary;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.summary_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.summary_value,
+        size,
+        is_null,
+        v);
+      i.summary_null = is_null;
+      i.summary_size = size;
+      grew = grew || (cap != i.summary_value.capacity ());
+    }
+
+    // description
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.description;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.description_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.description_value,
+        size,
+        is_null,
+        v);
+      i.description_null = is_null;
+      i.description_size = size;
+      grew = grew || (cap != i.description_value.capacity ());
+    }
+
+    // description_type
+    //
+    {
+      ::butl::optional< ::bpkg::text_type > const& v =
+        o.description_type;
+
+      // From package.hxx:58:14
+      ::brep::optional_string const& vt =
+        (v) ? to_string ( * (v)) : brep::optional_string ();
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.description_type_value.capacity ());
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_image (
+        i.description_type_value,
+        size,
+        is_null,
+        vt);
+      i.description_type_null = is_null;
+      i.description_type_size = size;
+      grew = grew || (cap != i.description_type_value.capacity ());
+    }
+
+    // changes
+    //
+    {
+      ::std::string const& v =
+        o.changes;
+
+      bool is_null (false);
+      std::size_t size (0);
+      std::size_t cap (i.changes_value.capacity ());
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_image (
+        i.changes_value,
+        size,
+        is_null,
+        v);
+      i.changes_null = is_null;
+      i.changes_size = size;
+      grew = grew || (cap != i.changes_value.capacity ());
+    }
+
+    // url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url > const& v =
+        o.url;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v))
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null (
+          i.url_value, sk);
+      else
+      {
+        const::bpkg::manifest_url& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+              i.url_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // doc_url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url > const& v =
+        o.doc_url;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v))
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null (
+          i.doc_url_value, sk);
+      else
+      {
+        const::bpkg::manifest_url& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+              i.doc_url_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // src_url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url > const& v =
+        o.src_url;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v))
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null (
+          i.src_url_value, sk);
+      else
+      {
+        const::bpkg::manifest_url& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+              i.src_url_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // package_url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url > const& v =
+        o.package_url;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v))
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null (
+          i.package_url_value, sk);
+      else
+      {
+        const::bpkg::manifest_url& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+              i.package_url_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // email
+    //
+    {
+      ::butl::optional< ::bpkg::email > const& v =
+        o.email;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v))
+        composite_value_traits< ::bpkg::email, id_pgsql >::set_null (
+          i.email_value, sk);
+      else
+      {
+        const::bpkg::email& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::email, id_pgsql >::init (
+              i.email_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // package_email
+    //
+    {
+      ::butl::optional< ::bpkg::email > const& v =
+        o.package_email;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v))
+        composite_value_traits< ::bpkg::email, id_pgsql >::set_null (
+          i.package_email_value, sk);
+      else
+      {
+        const::bpkg::email& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::email, id_pgsql >::init (
+              i.package_email_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // build_email
+    //
+    {
+      ::butl::optional< ::bpkg::email > const& v =
+        o.build_email;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v))
+        composite_value_traits< ::bpkg::email, id_pgsql >::set_null (
+          i.build_email_value, sk);
+      else
+      {
+        const::bpkg::email& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::email, id_pgsql >::init (
+              i.build_email_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // build_warning_email
+    //
+    {
+      ::butl::optional< ::bpkg::email > const& v =
+        o.build_warning_email;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v))
+        composite_value_traits< ::bpkg::email, id_pgsql >::set_null (
+          i.build_warning_email_value, sk);
+      else
+      {
+        const::bpkg::email& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::email, id_pgsql >::init (
+              i.build_warning_email_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // build_error_email
+    //
+    {
+      ::butl::optional< ::bpkg::email > const& v =
+        o.build_error_email;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v))
+        composite_value_traits< ::bpkg::email, id_pgsql >::set_null (
+          i.build_error_email_value, sk);
+      else
+      {
+        const::bpkg::email& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::email, id_pgsql >::init (
+              i.build_error_email_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // internal_repository
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::repository > const& v =
+        o.internal_repository;
+
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::repository > > ptr_traits;
+
+      bool is_null (ptr_traits::null_ptr (v));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (v));
+
+        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+              i.internal_repository_value,
+              ptr_id,
+              sk))
+          grew = true;
+      }
+      else
+        composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.internal_repository_value, sk);
+    }
+
+    // location
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::any_path_kind< char > > > const& v =
+        o.location;
+
+      // From common.hxx:101:14
+      ::brep::optional_string const& vt =
+        (v) ? (v)->string () : brep::optional_string ();
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.location_value.capacity ());
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_image (
+        i.location_value,
+        size,
+        is_null,
+        vt);
+      i.location_null = is_null;
+      i.location_size = size;
+      grew = grew || (cap != i.location_value.capacity ());
+    }
+
+    // fragment
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.fragment;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.fragment_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.fragment_value,
+        size,
+        is_null,
+        v);
+      i.fragment_null = is_null;
+      i.fragment_size = size;
+      grew = grew || (cap != i.fragment_value.capacity ());
+    }
+
+    // sha256sum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.sha256sum;
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.sha256sum_value.capacity ());
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_image (
+        i.sha256sum_value,
+        size,
+        is_null,
+        v);
+      i.sha256sum_null = is_null;
+      i.sha256sum_size = size;
+      grew = grew || (cap != i.sha256sum_value.capacity ());
+    }
+
+    // buildable
+    //
+    {
+      bool const& v =
+        o.buildable;
+
+      bool is_null (false);
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_image (
+        i.buildable_value, is_null, v);
+      i.buildable_null = is_null;
+    }
+
+    // unbuildable_reason
+    //
+    {
+      ::butl::optional< ::brep::unbuildable_reason > const& v =
+        o.unbuildable_reason;
+
+      // From common.hxx:352:14
+      ::brep::optional_string const& vt =
+        (v) ? to_string ( * (v)) : brep::optional_string ();
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.unbuildable_reason_value.capacity ());
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_image (
+        i.unbuildable_reason_value,
+        size,
+        is_null,
+        vt);
+      i.unbuildable_reason_null = is_null;
+      i.unbuildable_reason_size = size;
+      grew = grew || (cap != i.unbuildable_reason_value.capacity ());
+    }
+
+    // search_index
+    //
+    {
+      // From package.hxx:610:7
+      ::brep::weighted_text const& v =
+        o.search_text ();
+
+      bool is_null (true);
+      std::size_t size (0);
+      std::size_t cap (i.search_index_value.capacity ());
+      pgsql::value_traits<
+          ::brep::weighted_text,
+          pgsql::id_string >::set_image (
+        i.search_index_value,
+        size,
+        is_null,
+        v);
+      i.search_index_null = is_null;
+      i.search_index_size = size;
+      grew = grew || (cap != i.search_index_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::package_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // version
+    //
+    {
+      // From package.hxx:523:32
+      ::brep::package::upstream_version_type v;
+
+      composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::init (
+        v,
+        i.version_value,
+        db);
+
+      // From package.hxx:523:32
+      o.version.init (o.id.version, (v));
+    }
+
+    // upstream_version
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.upstream_version;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.upstream_version_value,
+        i.upstream_version_size,
+        i.upstream_version_null);
+    }
+
+    // project
+    //
+    {
+      ::bpkg::package_name& v =
+        o.project;
+
+      pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::set_value (
+        v,
+        i.project_value,
+        i.project_size,
+        i.project_null);
+    }
+
+    // priority
+    //
+    {
+      ::brep::package::priority_type& v =
+        o.priority;
+
+      composite_value_traits< ::brep::package::priority_type, id_pgsql >::init (
+        v,
+        i.priority_value,
+        db);
+    }
+
+    // summary
+    //
+    {
+      ::std::string& v =
+        o.summary;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.summary_value,
+        i.summary_size,
+        i.summary_null);
+    }
+
+    // description
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.description;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.description_value,
+        i.description_size,
+        i.description_null);
+    }
+
+    // description_type
+    //
+    {
+      ::butl::optional< ::bpkg::text_type >& v =
+        o.description_type;
+
+      ::brep::optional_string vt;
+
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.description_type_value,
+        i.description_type_size,
+        i.description_type_null);
+
+      // From package.hxx:58:14
+      v = (vt) ? brep::to_text_type ( * (vt)) : brep::optional_text_type ();
+    }
+
+    // changes
+    //
+    {
+      ::std::string& v =
+        o.changes;
+
+      pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::set_value (
+        v,
+        i.changes_value,
+        i.changes_size,
+        i.changes_null);
+    }
+
+    // url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url >& v =
+        o.url;
+
+      if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null (
+            i.url_value))
+        wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v);
+      else
+      {
+        ::bpkg::manifest_url& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+          vw,
+          i.url_value,
+          db);
+      }
+    }
+
+    // doc_url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url >& v =
+        o.doc_url;
+
+      if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null (
+            i.doc_url_value))
+        wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v);
+      else
+      {
+        ::bpkg::manifest_url& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+          vw,
+          i.doc_url_value,
+          db);
+      }
+    }
+
+    // src_url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url >& v =
+        o.src_url;
+
+      if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null (
+            i.src_url_value))
+        wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v);
+      else
+      {
+        ::bpkg::manifest_url& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+          vw,
+          i.src_url_value,
+          db);
+      }
+    }
+
+    // package_url
+    //
+    {
+      ::butl::optional< ::bpkg::manifest_url >& v =
+        o.package_url;
+
+      if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null (
+            i.package_url_value))
+        wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v);
+      else
+      {
+        ::bpkg::manifest_url& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init (
+          vw,
+          i.package_url_value,
+          db);
+      }
+    }
+
+    // email
+    //
+    {
+      ::butl::optional< ::bpkg::email >& v =
+        o.email;
+
+      if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null (
+            i.email_value))
+        wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v);
+      else
+      {
+        ::bpkg::email& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::email, id_pgsql >::init (
+          vw,
+          i.email_value,
+          db);
+      }
+    }
+
+    // package_email
+    //
+    {
+      ::butl::optional< ::bpkg::email >& v =
+        o.package_email;
+
+      if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null (
+            i.package_email_value))
+        wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v);
+      else
+      {
+        ::bpkg::email& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::email, id_pgsql >::init (
+          vw,
+          i.package_email_value,
+          db);
+      }
+    }
+
+    // build_email
+    //
+    {
+      ::butl::optional< ::bpkg::email >& v =
+        o.build_email;
+
+      if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null (
+            i.build_email_value))
+        wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v);
+      else
+      {
+        ::bpkg::email& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::email, id_pgsql >::init (
+          vw,
+          i.build_email_value,
+          db);
+      }
+    }
+
+    // build_warning_email
+    //
+    {
+      ::butl::optional< ::bpkg::email >& v =
+        o.build_warning_email;
+
+      if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null (
+            i.build_warning_email_value))
+        wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v);
+      else
+      {
+        ::bpkg::email& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::email, id_pgsql >::init (
+          vw,
+          i.build_warning_email_value,
+          db);
+      }
+    }
+
+    // build_error_email
+    //
+    {
+      ::butl::optional< ::bpkg::email >& v =
+        o.build_error_email;
+
+      if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null (
+            i.build_error_email_value))
+        wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v);
+      else
+      {
+        ::bpkg::email& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::email, id_pgsql >::init (
+          vw,
+          i.build_error_email_value,
+          db);
+      }
+    }
+
+    // internal_repository
+    //
+    {
+      ::odb::lazy_shared_ptr< ::brep::repository >& v =
+        o.internal_repository;
+
+      typedef object_traits< ::brep::repository > obj_traits;
+      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::repository > > ptr_traits;
+
+      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
+            i.internal_repository_value))
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
+          ptr_id,
+          i.internal_repository_value,
+          db);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<pgsql::database*> (db), ptr_id);
+      }
+    }
+
+    // location
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::any_path_kind< char > > >& v =
+        o.location;
+
+      ::brep::optional_string vt;
+
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.location_value,
+        i.location_size,
+        i.location_null);
+
+      // From common.hxx:101:14
+      v = (vt) ? brep::path ( * (vt)) : brep::optional_path ();
+    }
+
+    // fragment
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.fragment;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.fragment_value,
+        i.fragment_size,
+        i.fragment_null);
+    }
+
+    // sha256sum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.sha256sum;
+
+      pgsql::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          pgsql::id_string >::set_value (
+        v,
+        i.sha256sum_value,
+        i.sha256sum_size,
+        i.sha256sum_null);
+    }
+
+    // buildable
+    //
+    {
+      bool& v =
+        o.buildable;
+
+      pgsql::value_traits<
+          bool,
+          pgsql::id_boolean >::set_value (
+        v,
+        i.buildable_value,
+        i.buildable_null);
+    }
+
+    // unbuildable_reason
+    //
+    {
+      ::butl::optional< ::brep::unbuildable_reason >& v =
+        o.unbuildable_reason;
+
+      ::brep::optional_string vt;
+
+      pgsql::value_traits<
+          ::brep::optional_string,
+          pgsql::id_string >::set_value (
+        vt,
+        i.unbuildable_reason_value,
+        i.unbuildable_reason_size,
+        i.unbuildable_reason_null);
+
+      // From common.hxx:352:14
+      v = (vt) ? brep::to_unbuildable_reason ( * (vt)) : brep::optional_unbuildable_reason ();
+    }
+
+    // search_index
+    //
+    {
+      // From package.hxx:610:7
+      ::brep::weighted_text v;
+
+      pgsql::value_traits<
+          ::brep::weighted_text,
+          pgsql::id_string >::set_value (
+        v,
+        i.search_index_value,
+        i.search_index_size,
+        i.search_index_null);
+
+      // From package.hxx:610:7
+      o.search_text (v);
+    }
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    pgsql::statement_kind sk (pgsql::statement_select);
+    {
+      if (composite_value_traits< ::brep::package_id, id_pgsql >::init (
+            i.id_value,
+            id,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::persist_statement[] =
+  "INSERT INTO \"package\" "
+  "(\"tenant\", "
+  "\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_upstream\", "
+  "\"version_release\", "
+  "\"upstream_version\", "
+  "\"project\", "
+  "\"priority\", "
+  "\"priority_comment\", "
+  "\"summary\", "
+  "\"description\", "
+  "\"description_type\", "
+  "\"changes\", "
+  "\"url\", "
+  "\"url_comment\", "
+  "\"doc_url\", "
+  "\"doc_url_comment\", "
+  "\"src_url\", "
+  "\"src_url_comment\", "
+  "\"package_url\", "
+  "\"package_url_comment\", "
+  "\"email\", "
+  "\"email_comment\", "
+  "\"package_email\", "
+  "\"package_email_comment\", "
+  "\"build_email\", "
+  "\"build_email_comment\", "
+  "\"build_warning_email\", "
+  "\"build_warning_email_comment\", "
+  "\"build_error_email\", "
+  "\"build_error_email_comment\", "
+  "\"internal_repository_tenant\", "
+  "\"internal_repository_canonical_name\", "
+  "\"location\", "
+  "\"fragment\", "
+  "\"sha256sum\", "
+  "\"buildable\", "
+  "\"unbuildable_reason\", "
+  "\"search_index\") "
+  "VALUES "
+  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10::CITEXT, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30, $31, $32, $33, $34, $35, $36, $37, $38, $39, $40, $41, to_tsvector($42::weighted_text))";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::find_statement[] =
+  "SELECT "
+  "\"package\".\"tenant\", "
+  "\"package\".\"name\"::TEXT, "
+  "\"package\".\"version_epoch\", "
+  "\"package\".\"version_canonical_upstream\", "
+  "\"package\".\"version_canonical_release\", "
+  "\"package\".\"version_revision\", "
+  "\"package\".\"version_upstream\", "
+  "\"package\".\"version_release\", "
+  "\"package\".\"upstream_version\", "
+  "\"package\".\"project\"::TEXT, "
+  "\"package\".\"priority\", "
+  "\"package\".\"priority_comment\", "
+  "\"package\".\"summary\", "
+  "\"package\".\"description\", "
+  "\"package\".\"description_type\", "
+  "\"package\".\"changes\", "
+  "\"package\".\"url\", "
+  "\"package\".\"url_comment\", "
+  "\"package\".\"doc_url\", "
+  "\"package\".\"doc_url_comment\", "
+  "\"package\".\"src_url\", "
+  "\"package\".\"src_url_comment\", "
+  "\"package\".\"package_url\", "
+  "\"package\".\"package_url_comment\", "
+  "\"package\".\"email\", "
+  "\"package\".\"email_comment\", "
+  "\"package\".\"package_email\", "
+  "\"package\".\"package_email_comment\", "
+  "\"package\".\"build_email\", "
+  "\"package\".\"build_email_comment\", "
+  "\"package\".\"build_warning_email\", "
+  "\"package\".\"build_warning_email_comment\", "
+  "\"package\".\"build_error_email\", "
+  "\"package\".\"build_error_email_comment\", "
+  "\"package\".\"internal_repository_tenant\", "
+  "\"package\".\"internal_repository_canonical_name\", "
+  "\"package\".\"location\", "
+  "\"package\".\"fragment\", "
+  "\"package\".\"sha256sum\", "
+  "\"package\".\"buildable\", "
+  "\"package\".\"unbuildable_reason\", "
+  "COALESCE('',\"package\".\"search_index\") "
+  "FROM \"package\" "
+  "WHERE \"package\".\"tenant\"=$1 AND \"package\".\"name\"=$2::CITEXT AND \"package\".\"version_epoch\"=$3 AND \"package\".\"version_canonical_upstream\"=$4 AND \"package\".\"version_canonical_release\"=$5 AND \"package\".\"version_revision\"=$6";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::update_statement[] =
+  "UPDATE \"package\" "
+  "SET "
+  "\"version_upstream\"=$1, "
+  "\"version_release\"=$2, "
+  "\"upstream_version\"=$3, "
+  "\"project\"=$4::CITEXT, "
+  "\"priority\"=$5, "
+  "\"priority_comment\"=$6, "
+  "\"summary\"=$7, "
+  "\"description\"=$8, "
+  "\"description_type\"=$9, "
+  "\"changes\"=$10, "
+  "\"url\"=$11, "
+  "\"url_comment\"=$12, "
+  "\"doc_url\"=$13, "
+  "\"doc_url_comment\"=$14, "
+  "\"src_url\"=$15, "
+  "\"src_url_comment\"=$16, "
+  "\"package_url\"=$17, "
+  "\"package_url_comment\"=$18, "
+  "\"email\"=$19, "
+  "\"email_comment\"=$20, "
+  "\"package_email\"=$21, "
+  "\"package_email_comment\"=$22, "
+  "\"build_email\"=$23, "
+  "\"build_email_comment\"=$24, "
+  "\"build_warning_email\"=$25, "
+  "\"build_warning_email_comment\"=$26, "
+  "\"build_error_email\"=$27, "
+  "\"build_error_email_comment\"=$28, "
+  "\"internal_repository_tenant\"=$29, "
+  "\"internal_repository_canonical_name\"=$30, "
+  "\"location\"=$31, "
+  "\"fragment\"=$32, "
+  "\"sha256sum\"=$33, "
+  "\"buildable\"=$34, "
+  "\"unbuildable_reason\"=$35, "
+  "\"search_index\"=to_tsvector($36::weighted_text) "
+  "WHERE \"tenant\"=$37 AND \"name\"=$38::CITEXT AND \"version_epoch\"=$39 AND \"version_canonical_upstream\"=$40 AND \"version_canonical_release\"=$41 AND \"version_revision\"=$42";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::erase_statement[] =
+  "DELETE FROM \"package\" "
+  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::query_statement[] =
+  "SELECT\n"
+  "\"package\".\"tenant\",\n"
+  "\"package\".\"name\"::TEXT,\n"
+  "\"package\".\"version_epoch\",\n"
+  "\"package\".\"version_canonical_upstream\",\n"
+  "\"package\".\"version_canonical_release\",\n"
+  "\"package\".\"version_revision\",\n"
+  "\"package\".\"version_upstream\",\n"
+  "\"package\".\"version_release\",\n"
+  "\"package\".\"upstream_version\",\n"
+  "\"package\".\"project\"::TEXT,\n"
+  "\"package\".\"priority\",\n"
+  "\"package\".\"priority_comment\",\n"
+  "\"package\".\"summary\",\n"
+  "\"package\".\"description\",\n"
+  "\"package\".\"description_type\",\n"
+  "\"package\".\"changes\",\n"
+  "\"package\".\"url\",\n"
+  "\"package\".\"url_comment\",\n"
+  "\"package\".\"doc_url\",\n"
+  "\"package\".\"doc_url_comment\",\n"
+  "\"package\".\"src_url\",\n"
+  "\"package\".\"src_url_comment\",\n"
+  "\"package\".\"package_url\",\n"
+  "\"package\".\"package_url_comment\",\n"
+  "\"package\".\"email\",\n"
+  "\"package\".\"email_comment\",\n"
+  "\"package\".\"package_email\",\n"
+  "\"package\".\"package_email_comment\",\n"
+  "\"package\".\"build_email\",\n"
+  "\"package\".\"build_email_comment\",\n"
+  "\"package\".\"build_warning_email\",\n"
+  "\"package\".\"build_warning_email_comment\",\n"
+  "\"package\".\"build_error_email\",\n"
+  "\"package\".\"build_error_email_comment\",\n"
+  "\"package\".\"internal_repository_tenant\",\n"
+  "\"package\".\"internal_repository_canonical_name\",\n"
+  "\"package\".\"location\",\n"
+  "\"package\".\"fragment\",\n"
+  "\"package\".\"sha256sum\",\n"
+  "\"package\".\"buildable\",\n"
+  "\"package\".\"unbuildable_reason\",\n"
+  "COALESCE('',\"package\".\"search_index\")\n"
+  "FROM \"package\"\n"
+  "LEFT JOIN \"repository\" AS \"internal_repository\" ON \"internal_repository\".\"tenant\"=\"package\".\"internal_repository_tenant\" AND \"internal_repository\".\"canonical_name\"=\"package\".\"internal_repository_canonical_name\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::erase_query_statement[] =
+  "DELETE FROM \"package\"";
+
+  const char access::object_traits_impl< ::brep::package, id_pgsql >::table_name[] =
+  "\"package\"";
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  persist (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // license_alternatives
+    //
+    {
+      ::brep::package::license_alternatives_type const& v =
+        obj.license_alternatives;
+
+      license_alternatives_traits::persist (
+        v,
+        esc.license_alternatives);
+    }
+
+    // licenses
+    //
+    {
+      // From package.hxx:538:7
+      ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > const& v =
+        odb::nested_get (obj.license_alternatives);
+
+      licenses_traits::persist (
+        v,
+        esc.licenses);
+    }
+
+    // topics
+    //
+    {
+      ::butl::small_vector< ::std::basic_string< char >, 5 > const& v =
+        obj.topics;
+
+      topics_traits::persist (
+        v,
+        esc.topics);
+    }
+
+    // keywords
+    //
+    {
+      ::butl::small_vector< ::std::basic_string< char >, 5 > const& v =
+        obj.keywords;
+
+      keywords_traits::persist (
+        v,
+        esc.keywords);
+    }
+
+    // dependencies
+    //
+    {
+      ::brep::package::dependencies_type const& v =
+        obj.dependencies;
+
+      dependencies_traits::persist (
+        v,
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      // From package.hxx:564:7
+      ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > const& v =
+        odb::nested_get (obj.dependencies);
+
+      dependency_alternatives_traits::persist (
+        v,
+        esc.dependency_alternatives);
+    }
+
+    // requirements
+    //
+    {
+      ::brep::package::requirements_type const& v =
+        obj.requirements;
+
+      requirements_traits::persist (
+        v,
+        esc.requirements);
+    }
+
+    // requirement_alternatives
+    //
+    {
+      // From package.hxx:582:7
+      ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > const& v =
+        odb::nested_get (obj.requirements);
+
+      requirement_alternatives_traits::persist (
+        v,
+        esc.requirement_alternatives);
+    }
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::brep::test_dependency, 1 > const& v =
+        obj.tests;
+
+      tests_traits::persist (
+        v,
+        esc.tests);
+    }
+
+    // builds
+    //
+    {
+      ::brep::build_class_exprs const& v =
+        obj.builds;
+
+      builds_traits::persist (
+        v,
+        esc.builds);
+    }
+
+    // build_constraints
+    //
+    {
+      ::brep::package::build_constraints_type const& v =
+        obj.build_constraints;
+
+      build_constraints_traits::persist (
+        v,
+        esc.build_constraints);
+    }
+
+    // other_repositories
+    //
+    {
+      ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > > const& v =
+        obj.other_repositories;
+
+      other_repositories_traits::persist (
+        v,
+        esc.other_repositories);
+    }
+
+    obj.build_section.reset (true, false);
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace pgsql;
+    using pgsql::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    pgsql::transaction& tr (pgsql::transaction::current ());
+    pgsql::connection& conn (tr.connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // license_alternatives
+    //
+    {
+      ::brep::package::license_alternatives_type const& v =
+        obj.license_alternatives;
+
+      license_alternatives_traits::update (
+        v,
+        esc.license_alternatives);
+    }
+
+    // licenses
+    //
+    {
+      // From package.hxx:538:7
+      ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > const& v =
+        odb::nested_get (obj.license_alternatives);
+
+      licenses_traits::update (
+        v,
+        esc.licenses);
+    }
+
+    // topics
+    //
+    {
+      ::butl::small_vector< ::std::basic_string< char >, 5 > const& v =
+        obj.topics;
+
+      topics_traits::update (
+        v,
+        esc.topics);
+    }
+
+    // keywords
+    //
+    {
+      ::butl::small_vector< ::std::basic_string< char >, 5 > const& v =
+        obj.keywords;
+
+      keywords_traits::update (
+        v,
+        esc.keywords);
+    }
+
+    // dependencies
+    //
+    {
+      ::brep::package::dependencies_type const& v =
+        obj.dependencies;
+
+      dependencies_traits::update (
+        v,
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      // From package.hxx:564:7
+      ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > const& v =
+        odb::nested_get (obj.dependencies);
+
+      dependency_alternatives_traits::update (
+        v,
+        esc.dependency_alternatives);
+    }
+
+    // requirements
+    //
+    {
+      ::brep::package::requirements_type const& v =
+        obj.requirements;
+
+      requirements_traits::update (
+        v,
+        esc.requirements);
+    }
+
+    // requirement_alternatives
+    //
+    {
+      // From package.hxx:582:7
+      ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > const& v =
+        odb::nested_get (obj.requirements);
+
+      requirement_alternatives_traits::update (
+        v,
+        esc.requirement_alternatives);
+    }
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::brep::test_dependency, 1 > const& v =
+        obj.tests;
+
+      tests_traits::update (
+        v,
+        esc.tests);
+    }
+
+    // other_repositories
+    //
+    {
+      ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > > const& v =
+        obj.other_repositories;
+
+      other_repositories_traits::update (
+        v,
+        esc.other_repositories);
+    }
+
+    if (obj.build_section.loaded ())
+    {
+      build_section_traits::update (esc, obj);
+    }
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    ODB_POTENTIALLY_UNUSED (db);
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // license_alternatives
+    //
+    {
+      license_alternatives_traits::erase (
+        esc.license_alternatives);
+    }
+
+    // licenses
+    //
+    {
+      licenses_traits::erase (
+        esc.licenses);
+    }
+
+    // topics
+    //
+    {
+      topics_traits::erase (
+        esc.topics);
+    }
+
+    // keywords
+    //
+    {
+      keywords_traits::erase (
+        esc.keywords);
+    }
+
+    // dependencies
+    //
+    {
+      dependencies_traits::erase (
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      dependency_alternatives_traits::erase (
+        esc.dependency_alternatives);
+    }
+
+    // requirements
+    //
+    {
+      requirements_traits::erase (
+        esc.requirements);
+    }
+
+    // requirement_alternatives
+    //
+    {
+      requirement_alternatives_traits::erase (
+        esc.requirement_alternatives);
+    }
+
+    // tests
+    //
+    {
+      tests_traits::erase (
+        esc.tests);
+    }
+
+    // builds
+    //
+    {
+      builds_traits::erase (
+        esc.builds);
+    }
+
+    // build_constraints
+    //
+    {
+      build_constraints_traits::erase (
+        esc.build_constraints);
+    }
+
+    // other_repositories
+    //
+    {
+      other_repositories_traits::erase (
+        esc.other_repositories);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::brep::package, id_pgsql >::pointer_type
+  access::object_traits_impl< ::brep::package, id_pgsql >::
+  find (database& db, const id_type& id)
+  {
+    using namespace pgsql;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::
+  load (connection& conn, object_type& obj, section& s)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& c (static_cast<pgsql::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    bool r (false);
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    if (!r && &s == &obj.build_section)
+    {
+      build_section_traits::load (esc, obj);
+      r = true;
+    }
+
+    sts.load_delayed (0);
+    l.unlock ();
+    return r;
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::
+  update (connection& conn, const object_type& obj, const section& s)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& c (static_cast<pgsql::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (&s == &obj.build_section)build_section_traits::update (esc, obj);
+    else
+      return false;
+
+    return true;
+  }
+
+  bool access::object_traits_impl< ::brep::package, id_pgsql >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace pgsql;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // license_alternatives
+    //
+    {
+      ::brep::package::license_alternatives_type& v =
+        obj.license_alternatives;
+
+      license_alternatives_traits::load (
+        v,
+        esc.license_alternatives);
+    }
+
+    // licenses
+    //
+    {
+      ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > v;
+
+      licenses_traits::load (
+        v,
+        esc.licenses);
+
+      // From package.hxx:539:7
+      odb::nested_set (obj.license_alternatives, std::move (v));
+    }
+
+    // topics
+    //
+    {
+      ::butl::small_vector< ::std::basic_string< char >, 5 >& v =
+        obj.topics;
+
+      topics_traits::load (
+        v,
+        esc.topics);
+    }
+
+    // keywords
+    //
+    {
+      ::butl::small_vector< ::std::basic_string< char >, 5 >& v =
+        obj.keywords;
+
+      keywords_traits::load (
+        v,
+        esc.keywords);
+    }
+
+    // dependencies
+    //
+    {
+      ::brep::package::dependencies_type& v =
+        obj.dependencies;
+
+      dependencies_traits::load (
+        v,
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > v;
+
+      dependency_alternatives_traits::load (
+        v,
+        esc.dependency_alternatives);
+
+      // From package.hxx:565:7
+      odb::nested_set (obj.dependencies, std::move (v));
+    }
+
+    // requirements
+    //
+    {
+      ::brep::package::requirements_type& v =
+        obj.requirements;
+
+      requirements_traits::load (
+        v,
+        esc.requirements);
+    }
+
+    // requirement_alternatives
+    //
+    {
+      ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > v;
+
+      requirement_alternatives_traits::load (
+        v,
+        esc.requirement_alternatives);
+
+      // From package.hxx:583:7
+      odb::nested_set (obj.requirements, std::move (v));
+    }
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::brep::test_dependency, 1 >& v =
+        obj.tests;
+
+      tests_traits::load (
+        v,
+        esc.tests);
+    }
+
+    // other_repositories
+    //
+    {
+      ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > >& v =
+        obj.other_repositories;
+
+      other_repositories_traits::load (
+        v,
+        esc.other_repositories);
+    }
+
+    if (reload)
+    {
+      if (obj.build_section.loaded ())
+      {
+        build_section_traits::load (esc, obj);
+        obj.build_section.reset (true, false);
+      }
+    }
+    else
+      obj.build_section.reset ();
+  }
+
+  result< access::object_traits_impl< ::brep::package, id_pgsql >::object_type >
+  access::object_traits_impl< ::brep::package, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += "\n";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        text,
+        true,
+        true,
+        q.parameter_types (),
+        q.parameter_count (),
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) pgsql::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::brep::package, id_pgsql >::
+  erase_query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      erase_query_statement_name,
+      text,
+      q.parameter_types (),
+      q.parameter_count (),
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::brep::package, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += "\n";
+      text += q.clause ();
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        text,
+        true,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::brep::package, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // latest_package_search_rank
+  //
+
+  const char access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  query_statement_name[] = "query_brep_latest_package_search_rank";
+
+  bool access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // rank
+    //
+    t[6UL] = 0;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // id
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+    n += 6UL;
+
+    // rank
+    //
+    b[n].type = pgsql::bind::double_;
+    b[n].buffer = &i.rank_value;
+    b[n].is_null = &i.rank_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::package_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // rank
+    //
+    {
+      double& v =
+        o.rank;
+
+      pgsql::value_traits<
+          double,
+          pgsql::id_double >::set_value (
+        v,
+        i.rank_value,
+        i.rank_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT * FROM search_latest_packages" + q);
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // latest_package_count
+  //
+
+  const char access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  query_statement_name[] = "query_brep_latest_package_count";
+
+  bool access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = 0;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      pgsql::value_traits<
+          ::std::size_t,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT count(*) FROM search_latest_packages" + q);
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // package_search_rank
+  //
+
+  const char access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  query_statement_name[] = "query_brep_package_search_rank";
+
+  bool access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // rank
+    //
+    t[6UL] = 0;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // id
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+    n += 6UL;
+
+    // rank
+    //
+    b[n].type = pgsql::bind::double_;
+    b[n].buffer = &i.rank_value;
+    b[n].is_null = &i.rank_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::package_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // rank
+    //
+    {
+      double& v =
+        o.rank;
+
+      pgsql::value_traits<
+          double,
+          pgsql::id_double >::set_value (
+        v,
+        i.rank_value,
+        i.rank_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT * FROM search_packages" + q);
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // package_count
+  //
+
+  const char access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  query_statement_name[] = "query_brep_package_count";
+
+  bool access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = 0;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = pgsql::bind::bigint;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      pgsql::value_traits<
+          ::std::size_t,
+          pgsql::id_bigint >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::brep::package_count, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT count(*) FROM search_packages" + q);
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::package_count, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::package_count, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // latest_package
+  //
+
+  const char access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  query_statement_name[] = "query_brep_latest_package";
+
+  bool access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  bind (pgsql::bind* b,
+        image_type& i)
+  {
+    using namespace pgsql;
+
+    pgsql::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // id
+    //
+    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
+      b + n, i.id_value, sk);
+    n += 6UL;
+  }
+
+  void access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::brep::package_id& v =
+        o.id;
+
+      composite_value_traits< ::brep::package_id, id_pgsql >::init (
+        v,
+        i.id_value,
+        db);
+    }
+  }
+
+  access::view_traits_impl< ::brep::latest_package, id_pgsql >::query_base_type
+  access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT * FROM latest_package" + q);
+    return r;
+  }
+
+  result< access::view_traits_impl< ::brep::latest_package, id_pgsql >::view_type >
+  access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  query (database&, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        sts.connection (),
+        query_statement_name,
+        qs.clause (),
+        false,
+        true,
+        qs.parameter_types (),
+        qs.parameter_count (),
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+    st->deallocate ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) pgsql::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::connection& conn (
+      static_cast<pgsql::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<pgsql::prepared_query_impl> r (
+      new (shared) pgsql::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        sts.connection (),
+        n,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameter_types (),
+        r->query.parameter_count (),
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::brep::latest_package, id_pgsql >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace pgsql;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    pgsql::prepared_query_impl& pq (
+      static_cast<pgsql::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    pgsql::connection& conn (
+      pgsql::transaction::current ().connection ());
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (&conn == &st->connection ());
+
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) pgsql::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+}
+
+namespace odb
+{
+  static bool
+  create_schema (database& db, unsigned short pass, bool drop)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (pass);
+    ODB_POTENTIALLY_UNUSED (drop);
+
+    if (drop)
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("DROP TABLE IF EXISTS \"package_other_repositories\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_build_constraints\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_builds\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_tests\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_requirement_alternatives\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_requirements\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_dependency_alternatives\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_dependencies\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_keywords\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_topics\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_licenses\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package_license_alternatives\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"package\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"repository_prerequisites\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"repository_complements\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"repository\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"tenant\" CASCADE");
+          db.execute ("DROP TABLE IF EXISTS \"schema_version\"");
+          return false;
+        }
+      }
+    }
+    else
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          db.execute ("CREATE TABLE \"tenant\" (\n"
+                      "  \"id\" TEXT NOT NULL PRIMARY KEY,\n"
+                      "  \"creation_timestamp\" BIGINT NOT NULL,\n"
+                      "  \"archived\" BOOLEAN NOT NULL)");
+          db.execute ("CREATE TABLE \"repository\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"canonical_name\" TEXT NOT NULL,\n"
+                      "  \"location_url\" TEXT NOT NULL,\n"
+                      "  \"location_type\" TEXT NOT NULL,\n"
+                      "  \"display_name\" TEXT NOT NULL,\n"
+                      "  \"priority\" INTEGER NOT NULL,\n"
+                      "  \"interface_url\" TEXT NULL,\n"
+                      "  \"email\" TEXT NULL,\n"
+                      "  \"email_comment\" TEXT NULL,\n"
+                      "  \"summary\" TEXT NULL,\n"
+                      "  \"description\" TEXT NULL,\n"
+                      "  \"cache_location_url\" TEXT NOT NULL,\n"
+                      "  \"cache_location_type\" TEXT NOT NULL,\n"
+                      "  \"certificate_fingerprint\" TEXT NULL,\n"
+                      "  \"certificate_name\" TEXT NULL,\n"
+                      "  \"certificate_organization\" TEXT NULL,\n"
+                      "  \"certificate_email\" TEXT NULL,\n"
+                      "  \"certificate_pem\" TEXT NULL,\n"
+                      "  \"packages_timestamp\" BIGINT NOT NULL,\n"
+                      "  \"repositories_timestamp\" BIGINT NOT NULL,\n"
+                      "  \"internal\" BOOLEAN NOT NULL,\n"
+                      "  \"buildable\" BOOLEAN NOT NULL,\n"
+                      "  PRIMARY KEY (\"tenant\",\n"
+                      "               \"canonical_name\"),\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED)");
+          db.execute ("CREATE TABLE \"repository_complements\" (\n"
+                      "  \"repository_tenant\" TEXT NOT NULL,\n"
+                      "  \"repository_canonical_name\" TEXT NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"complement_tenant\" TEXT NOT NULL,\n"
+                      "  \"complement_canonical_name\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"repository_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"repository_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"repository_fk\"\n"
+                      "    FOREIGN KEY (\"repository_tenant\",\n"
+                      "                 \"repository_canonical_name\")\n"
+                      "    REFERENCES \"repository\" (\"tenant\",\n"
+                      "                             \"canonical_name\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"complement_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"complement_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"complement_fk\"\n"
+                      "    FOREIGN KEY (\"complement_tenant\",\n"
+                      "                 \"complement_canonical_name\")\n"
+                      "    REFERENCES \"repository\" (\"tenant\",\n"
+                      "                             \"canonical_name\")\n"
+                      "    INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"repository_complements_repository_i\"\n"
+                      "  ON \"repository_complements\" (\n"
+                      "    \"repository_tenant\",\n"
+                      "    \"repository_canonical_name\")");
+          db.execute ("CREATE INDEX \"repository_complements_index_i\"\n"
+                      "  ON \"repository_complements\" (\"index\")");
+          db.execute ("CREATE TABLE \"repository_prerequisites\" (\n"
+                      "  \"repository_tenant\" TEXT NOT NULL,\n"
+                      "  \"repository_canonical_name\" TEXT NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"prerequisite_tenant\" TEXT NOT NULL,\n"
+                      "  \"prerequisite_canonical_name\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"repository_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"repository_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"repository_fk\"\n"
+                      "    FOREIGN KEY (\"repository_tenant\",\n"
+                      "                 \"repository_canonical_name\")\n"
+                      "    REFERENCES \"repository\" (\"tenant\",\n"
+                      "                             \"canonical_name\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"prerequisite_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"prerequisite_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"prerequisite_fk\"\n"
+                      "    FOREIGN KEY (\"prerequisite_tenant\",\n"
+                      "                 \"prerequisite_canonical_name\")\n"
+                      "    REFERENCES \"repository\" (\"tenant\",\n"
+                      "                             \"canonical_name\")\n"
+                      "    INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"repository_prerequisites_repository_i\"\n"
+                      "  ON \"repository_prerequisites\" (\n"
+                      "    \"repository_tenant\",\n"
+                      "    \"repository_canonical_name\")");
+          db.execute ("CREATE INDEX \"repository_prerequisites_index_i\"\n"
+                      "  ON \"repository_prerequisites\" (\"index\")");
+          db.execute ("CREATE TABLE \"package\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"version_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_release\" TEXT NULL,\n"
+                      "  \"upstream_version\" TEXT NULL,\n"
+                      "  \"project\" CITEXT NOT NULL,\n"
+                      "  \"priority\" INTEGER NOT NULL,\n"
+                      "  \"priority_comment\" TEXT NOT NULL,\n"
+                      "  \"summary\" TEXT NOT NULL,\n"
+                      "  \"description\" TEXT NULL,\n"
+                      "  \"description_type\" TEXT NULL,\n"
+                      "  \"changes\" TEXT NOT NULL,\n"
+                      "  \"url\" TEXT NULL,\n"
+                      "  \"url_comment\" TEXT NULL,\n"
+                      "  \"doc_url\" TEXT NULL,\n"
+                      "  \"doc_url_comment\" TEXT NULL,\n"
+                      "  \"src_url\" TEXT NULL,\n"
+                      "  \"src_url_comment\" TEXT NULL,\n"
+                      "  \"package_url\" TEXT NULL,\n"
+                      "  \"package_url_comment\" TEXT NULL,\n"
+                      "  \"email\" TEXT NULL,\n"
+                      "  \"email_comment\" TEXT NULL,\n"
+                      "  \"package_email\" TEXT NULL,\n"
+                      "  \"package_email_comment\" TEXT NULL,\n"
+                      "  \"build_email\" TEXT NULL,\n"
+                      "  \"build_email_comment\" TEXT NULL,\n"
+                      "  \"build_warning_email\" TEXT NULL,\n"
+                      "  \"build_warning_email_comment\" TEXT NULL,\n"
+                      "  \"build_error_email\" TEXT NULL,\n"
+                      "  \"build_error_email_comment\" TEXT NULL,\n"
+                      "  \"internal_repository_tenant\" TEXT NULL,\n"
+                      "  \"internal_repository_canonical_name\" TEXT NULL,\n"
+                      "  \"location\" TEXT NULL,\n"
+                      "  \"fragment\" TEXT NULL,\n"
+                      "  \"sha256sum\" TEXT NULL,\n"
+                      "  \"buildable\" BOOLEAN NOT NULL,\n"
+                      "  \"unbuildable_reason\" TEXT NULL,\n"
+                      "  \"search_index\" tsvector NULL,\n"
+                      "  PRIMARY KEY (\"tenant\",\n"
+                      "               \"name\",\n"
+                      "               \"version_epoch\",\n"
+                      "               \"version_canonical_upstream\",\n"
+                      "               \"version_canonical_release\",\n"
+                      "               \"version_revision\"),\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"internal_repository_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"internal_repository_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"internal_repository_fk\"\n"
+                      "    FOREIGN KEY (\"internal_repository_tenant\",\n"
+                      "                 \"internal_repository_canonical_name\")\n"
+                      "    REFERENCES \"repository\" (\"tenant\",\n"
+                      "                             \"canonical_name\")\n"
+                      "    INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"package_search_index_i\"\n"
+                      "  ON \"package\" USING GIN (\"search_index\")");
+          db.execute ("CREATE TABLE \"package_license_alternatives\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"comment\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_license_alternatives_object_id_i\"\n"
+                      "  ON \"package_license_alternatives\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_license_alternatives_index_i\"\n"
+                      "  ON \"package_license_alternatives\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_licenses\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"alternative_index\" BIGINT NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"license\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_licenses_object_id_i\"\n"
+                      "  ON \"package_licenses\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE TABLE \"package_topics\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"topic\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_topics_object_id_i\"\n"
+                      "  ON \"package_topics\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_topics_index_i\"\n"
+                      "  ON \"package_topics\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_keywords\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"keyword\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_keywords_object_id_i\"\n"
+                      "  ON \"package_keywords\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_keywords_index_i\"\n"
+                      "  ON \"package_keywords\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_dependencies\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"conditional\" BOOLEAN NOT NULL,\n"
+                      "  \"buildtime\" BOOLEAN NOT NULL,\n"
+                      "  \"comment\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_dependencies_object_id_i\"\n"
+                      "  ON \"package_dependencies\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_dependencies_index_i\"\n"
+                      "  ON \"package_dependencies\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_dependency_alternatives\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"dependency_index\" BIGINT NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"dep_name\" CITEXT NOT NULL,\n"
+                      "  \"dep_min_version_epoch\" INTEGER NULL,\n"
+                      "  \"dep_min_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"dep_min_version_canonical_release\" TEXT NULL,\n"
+                      "  \"dep_min_version_revision\" INTEGER NULL,\n"
+                      "  \"dep_min_version_upstream\" TEXT NULL,\n"
+                      "  \"dep_min_version_release\" TEXT NULL,\n"
+                      "  \"dep_max_version_epoch\" INTEGER NULL,\n"
+                      "  \"dep_max_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"dep_max_version_canonical_release\" TEXT NULL,\n"
+                      "  \"dep_max_version_revision\" INTEGER NULL,\n"
+                      "  \"dep_max_version_upstream\" TEXT NULL,\n"
+                      "  \"dep_max_version_release\" TEXT NULL,\n"
+                      "  \"dep_min_open\" BOOLEAN NULL,\n"
+                      "  \"dep_max_open\" BOOLEAN NULL,\n"
+                      "  \"dep_package_tenant\" TEXT NULL,\n"
+                      "  \"dep_package_name\" CITEXT NULL,\n"
+                      "  \"dep_package_version_epoch\" INTEGER NULL,\n"
+                      "  \"dep_package_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"dep_package_version_canonical_release\" TEXT NULL COLLATE \"C\",\n"
+                      "  \"dep_package_version_revision\" INTEGER NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"dep_package_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"dep_package_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"dep_package_fk\"\n"
+                      "    FOREIGN KEY (\"dep_package_tenant\",\n"
+                      "                 \"dep_package_name\",\n"
+                      "                 \"dep_package_version_epoch\",\n"
+                      "                 \"dep_package_version_canonical_upstream\",\n"
+                      "                 \"dep_package_version_canonical_release\",\n"
+                      "                 \"dep_package_version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"package_dependency_alternatives_object_id_i\"\n"
+                      "  ON \"package_dependency_alternatives\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE TABLE \"package_requirements\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"conditional\" BOOLEAN NOT NULL,\n"
+                      "  \"buildtime\" BOOLEAN NOT NULL,\n"
+                      "  \"comment\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_requirements_object_id_i\"\n"
+                      "  ON \"package_requirements\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_requirements_index_i\"\n"
+                      "  ON \"package_requirements\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_requirement_alternatives\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"requirement_index\" BIGINT NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"id\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_requirement_alternatives_object_id_i\"\n"
+                      "  ON \"package_requirement_alternatives\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE TABLE \"package_tests\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"test_name\" CITEXT NOT NULL,\n"
+                      "  \"test_min_version_epoch\" INTEGER NULL,\n"
+                      "  \"test_min_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"test_min_version_canonical_release\" TEXT NULL,\n"
+                      "  \"test_min_version_revision\" INTEGER NULL,\n"
+                      "  \"test_min_version_upstream\" TEXT NULL,\n"
+                      "  \"test_min_version_release\" TEXT NULL,\n"
+                      "  \"test_max_version_epoch\" INTEGER NULL,\n"
+                      "  \"test_max_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"test_max_version_canonical_release\" TEXT NULL,\n"
+                      "  \"test_max_version_revision\" INTEGER NULL,\n"
+                      "  \"test_max_version_upstream\" TEXT NULL,\n"
+                      "  \"test_max_version_release\" TEXT NULL,\n"
+                      "  \"test_min_open\" BOOLEAN NULL,\n"
+                      "  \"test_max_open\" BOOLEAN NULL,\n"
+                      "  \"test_package_tenant\" TEXT NULL,\n"
+                      "  \"test_package_name\" CITEXT NULL,\n"
+                      "  \"test_package_version_epoch\" INTEGER NULL,\n"
+                      "  \"test_package_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"test_package_version_canonical_release\" TEXT NULL COLLATE \"C\",\n"
+                      "  \"test_package_version_revision\" INTEGER NULL,\n"
+                      "  \"test_type\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"test_package_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"test_package_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"test_package_fk\"\n"
+                      "    FOREIGN KEY (\"test_package_tenant\",\n"
+                      "                 \"test_package_name\",\n"
+                      "                 \"test_package_version_epoch\",\n"
+                      "                 \"test_package_version_canonical_upstream\",\n"
+                      "                 \"test_package_version_canonical_release\",\n"
+                      "                 \"test_package_version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"package_tests_object_id_i\"\n"
+                      "  ON \"package_tests\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_tests_index_i\"\n"
+                      "  ON \"package_tests\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_builds\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"expression\" TEXT NOT NULL,\n"
+                      "  \"comment\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_builds_object_id_i\"\n"
+                      "  ON \"package_builds\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_builds_index_i\"\n"
+                      "  ON \"package_builds\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_build_constraints\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"exclusion\" BOOLEAN NOT NULL,\n"
+                      "  \"config\" TEXT NOT NULL,\n"
+                      "  \"target\" TEXT NULL,\n"
+                      "  \"comment\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"package_build_constraints_object_id_i\"\n"
+                      "  ON \"package_build_constraints\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_build_constraints_index_i\"\n"
+                      "  ON \"package_build_constraints\" (\"index\")");
+          db.execute ("CREATE TABLE \"package_other_repositories\" (\n"
+                      "  \"tenant\" TEXT NOT NULL,\n"
+                      "  \"name\" CITEXT NOT NULL,\n"
+                      "  \"version_epoch\" INTEGER NOT NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NOT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n"
+                      "  \"version_revision\" INTEGER NOT NULL,\n"
+                      "  \"index\" BIGINT NOT NULL,\n"
+                      "  \"repository_tenant\" TEXT NOT NULL,\n"
+                      "  \"repository_canonical_name\" TEXT NOT NULL,\n"
+                      "  CONSTRAINT \"tenant_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"tenant\",\n"
+                      "                 \"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\")\n"
+                      "    REFERENCES \"package\" (\"tenant\",\n"
+                      "                          \"name\",\n"
+                      "                          \"version_epoch\",\n"
+                      "                          \"version_canonical_upstream\",\n"
+                      "                          \"version_canonical_release\",\n"
+                      "                          \"version_revision\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"repository_tenant_fk\"\n"
+                      "    FOREIGN KEY (\"repository_tenant\")\n"
+                      "    REFERENCES \"tenant\" (\"id\")\n"
+                      "    INITIALLY DEFERRED,\n"
+                      "  CONSTRAINT \"repository_fk\"\n"
+                      "    FOREIGN KEY (\"repository_tenant\",\n"
+                      "                 \"repository_canonical_name\")\n"
+                      "    REFERENCES \"repository\" (\"tenant\",\n"
+                      "                             \"canonical_name\")\n"
+                      "    INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"package_other_repositories_object_id_i\"\n"
+                      "  ON \"package_other_repositories\" (\n"
+                      "    \"tenant\",\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\")");
+          db.execute ("CREATE INDEX \"package_other_repositories_index_i\"\n"
+                      "  ON \"package_other_repositories\" (\"index\")");
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("CREATE TABLE \"schema_version\" (\n"
+                      "  \"name\" TEXT NOT NULL PRIMARY KEY,\n"
+                      "  \"version\" BIGINT NOT NULL,\n"
+                      "  \"migration\" BOOLEAN NOT NULL)");
+          db.execute ("INSERT INTO \"schema_version\" (\n"
+                      "  \"name\", \"version\", \"migration\")\n"
+                      "  VALUES ('package', 19, FALSE)");
+          return false;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  static const schema_catalog_create_entry
+  create_schema_entry_ (
+    id_pgsql,
+    "package",
+    &create_schema);
+
+  static const schema_catalog_migrate_entry
+  migrate_schema_entry_19_ (
+    id_pgsql,
+    "package",
+    19ULL,
+    0);
+}
+
+#include <odb/post.hxx>
diff --git a/libbrep/package-odb.hxx b/libbrep/package-odb.hxx
new file mode 100644
index 0000000..88e6f40
--- /dev/null
+++ b/libbrep/package-odb.hxx
@@ -0,0 +1,5717 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#ifndef LIBBREP_PACKAGE_ODB_HXX
+#define LIBBREP_PACKAGE_ODB_HXX
+
+// Begin prologue.
+//
+#include <libbrep/package-traits.hxx>
+//
+// End prologue.
+
+#include <odb/version.hxx>
+
+#if (ODB_VERSION != 20470UL)
+#error ODB runtime version mismatch
+#endif
+
+#include <odb/pre.hxx>
+
+#include <libbrep/package.hxx>
+
+#include <libbrep/common-odb.hxx>
+
+#include <memory>
+#include <cstddef>
+#include <utility>
+
+#include <odb/core.hxx>
+#include <odb/traits.hxx>
+#include <odb/callback.hxx>
+#include <odb/wrapper-traits.hxx>
+#include <odb/pointer-traits.hxx>
+#include <odb/container-traits.hxx>
+#include <odb/session.hxx>
+#include <odb/cache-traits.hxx>
+#include <odb/prepared-query.hxx>
+#include <odb/result.hxx>
+#include <odb/simple-object-result.hxx>
+#include <odb/view-image.hxx>
+#include <odb/view-result.hxx>
+
+#include <odb/details/unused.hxx>
+#include <odb/details/shared-ptr.hxx>
+
+namespace odb
+{
+  // tenant
+  //
+  template <>
+  struct class_traits< ::brep::tenant >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::tenant >
+  {
+    public:
+    typedef ::brep::tenant object_type;
+    typedef ::std::shared_ptr< ::brep::tenant > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::std::string id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // tenant_id
+  //
+  template <>
+  struct class_traits< ::brep::tenant_id >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::tenant_id >
+  {
+    public:
+    typedef ::brep::tenant_id view_type;
+    typedef ::brep::tenant_id* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // repository
+  //
+  template <>
+  struct class_traits< ::brep::repository >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::repository >
+  {
+    public:
+    typedef ::brep::repository object_type;
+    typedef ::std::shared_ptr< ::brep::repository > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::brep::repository_id id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // package
+  //
+  template <>
+  struct class_traits< ::brep::package >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::brep::package >
+  {
+    public:
+    typedef ::brep::package object_type;
+    typedef ::std::shared_ptr< ::brep::package > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::brep::package_id id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // latest_package_search_rank
+  //
+  template <>
+  struct class_traits< ::brep::latest_package_search_rank >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::latest_package_search_rank >
+  {
+    public:
+    typedef ::brep::latest_package_search_rank view_type;
+    typedef ::brep::latest_package_search_rank* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // latest_package_count
+  //
+  template <>
+  struct class_traits< ::brep::latest_package_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::latest_package_count >
+  {
+    public:
+    typedef ::brep::latest_package_count view_type;
+    typedef ::brep::latest_package_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // package_search_rank
+  //
+  template <>
+  struct class_traits< ::brep::package_search_rank >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::package_search_rank >
+  {
+    public:
+    typedef ::brep::package_search_rank view_type;
+    typedef ::brep::package_search_rank* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // package_count
+  //
+  template <>
+  struct class_traits< ::brep::package_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::package_count >
+  {
+    public:
+    typedef ::brep::package_count view_type;
+    typedef ::brep::package_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // latest_package
+  //
+  template <>
+  struct class_traits< ::brep::latest_package >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::brep::latest_package >
+  {
+    public:
+    typedef ::brep::latest_package view_type;
+    typedef ::brep::latest_package* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+}
+
+#include <odb/details/buffer.hxx>
+
+#include <odb/pgsql/version.hxx>
+#include <odb/pgsql/forward.hxx>
+#include <odb/pgsql/binding.hxx>
+#include <odb/pgsql/pgsql-types.hxx>
+#include <odb/pgsql/query.hxx>
+
+namespace odb
+{
+  // priority
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::priority, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::priority value_type;
+
+    struct image_type
+    {
+      // value
+      //
+      int value_value;
+      bool value_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // licenses
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::licenses, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::licenses value_type;
+
+    struct image_type
+    {
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 1UL;
+  };
+
+  // manifest_url
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::manifest_url value_type;
+
+    struct image_type
+    {
+      // value
+      //
+      details::buffer value_value;
+      std::size_t value_size;
+      bool value_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // email
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::email, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::email value_type;
+
+    struct image_type
+    {
+      // value
+      //
+      details::buffer value_value;
+      std::size_t value_size;
+      bool value_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // version_constraint
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::version_constraint value_type;
+
+    struct image_type
+    {
+      // min_version
+      //
+      composite_value_traits< ::brep::_version, id_pgsql >::image_type min_version_value;
+
+      // max_version
+      //
+      composite_value_traits< ::brep::_version, id_pgsql >::image_type max_version_value;
+
+      // min_open
+      //
+      bool min_open_value;
+      bool min_open_null;
+
+      // max_open
+      //
+      bool max_open_value;
+      bool max_open_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 14UL;
+  };
+
+  // requirement_alternatives
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >
+  {
+    public:
+    typedef ::bpkg::requirement_alternatives value_type;
+
+    struct image_type
+    {
+      // conditional
+      //
+      bool conditional_value;
+      bool conditional_null;
+
+      // buildtime
+      //
+      bool buildtime_value;
+      bool buildtime_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 3UL;
+  };
+
+  // dependency
+  //
+  template <>
+  class access::composite_value_traits< ::brep::dependency, id_pgsql >
+  {
+    public:
+    typedef ::brep::dependency value_type;
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // constraint
+      //
+      composite_value_traits< ::bpkg::version_constraint, id_pgsql >::image_type constraint_value;
+
+      // package
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type package_value;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 21UL;
+  };
+
+  // dependency_alternatives
+  //
+  template <>
+  class access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >
+  {
+    public:
+    typedef ::brep::dependency_alternatives value_type;
+
+    struct image_type
+    {
+      // conditional
+      //
+      bool conditional_value;
+      bool conditional_null;
+
+      // buildtime
+      //
+      bool buildtime_value;
+      bool buildtime_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 3UL;
+  };
+
+  // test_dependency
+  //
+  template <>
+  class access::composite_value_traits< ::brep::test_dependency, id_pgsql >
+  {
+    public:
+    typedef ::brep::test_dependency value_type;
+
+    struct image_type: composite_value_traits< ::brep::dependency, id_pgsql >::image_type
+    {
+      // type
+      //
+      details::buffer type_value;
+      std::size_t type_size;
+      bool type_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 22UL;
+  };
+
+  // certificate
+  //
+  template <>
+  class access::composite_value_traits< ::brep::certificate, id_pgsql >
+  {
+    public:
+    typedef ::brep::certificate value_type;
+
+    struct image_type
+    {
+      // fingerprint
+      //
+      details::buffer fingerprint_value;
+      std::size_t fingerprint_size;
+      bool fingerprint_null;
+
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // organization
+      //
+      details::buffer organization_value;
+      std::size_t organization_size;
+      bool organization_null;
+
+      // email
+      //
+      details::buffer email_value;
+      std::size_t email_size;
+      bool email_null;
+
+      // pem
+      //
+      details::buffer pem_value;
+      std::size_t pem_size;
+      bool pem_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 5UL;
+  };
+
+  // tenant
+  //
+  template <typename A>
+  struct query_columns< ::brep::tenant, id_pgsql, A >
+  {
+    // id
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    id_type_;
+
+    static const id_type_ id;
+
+    // creation_timestamp
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint64_t,
+        pgsql::id_bigint >::query_type,
+      pgsql::id_bigint >
+    creation_timestamp_type_;
+
+    static const creation_timestamp_type_ creation_timestamp;
+
+    // archived
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    archived_type_;
+
+    static const archived_type_ archived;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::tenant, id_pgsql, A >::id_type_
+  query_columns< ::brep::tenant, id_pgsql, A >::
+  id (A::table_name, "\"id\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::tenant, id_pgsql, A >::creation_timestamp_type_
+  query_columns< ::brep::tenant, id_pgsql, A >::
+  creation_timestamp (A::table_name, "\"creation_timestamp\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::tenant, id_pgsql, A >::archived_type_
+  query_columns< ::brep::tenant, id_pgsql, A >::
+  archived (A::table_name, "\"archived\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::brep::tenant, id_pgsql, A >:
+    query_columns< ::brep::tenant, id_pgsql, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::tenant, id_pgsql >:
+    public access::object_traits< ::brep::tenant >
+  {
+    public:
+    struct id_image_type
+    {
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      // creation_timestamp
+      //
+      long long creation_timestamp_value;
+      bool creation_timestamp_null;
+
+      // archived
+      //
+      bool archived_value;
+      bool archived_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 3UL;
+    static const std::size_t id_column_count = 1UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char update_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+    static const unsigned int update_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::tenant, id_common >:
+    public access::object_traits_impl< ::brep::tenant, id_pgsql >
+  {
+  };
+
+  // tenant_id
+  //
+  template <>
+  class access::view_traits_impl< ::brep::tenant_id, id_pgsql >:
+    public access::view_traits< ::brep::tenant_id >
+  {
+    public:
+    struct image_type
+    {
+      // value
+      //
+      details::buffer value_value;
+      std::size_t value_size;
+      bool value_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::tenant_id, id_common >:
+    public access::view_traits_impl< ::brep::tenant_id, id_pgsql >
+  {
+  };
+
+  // repository
+  //
+  template <typename A>
+  struct query_columns< ::brep::repository, id_pgsql, A >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // canonical_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      canonical_name_type_;
+
+      static const canonical_name_type_ canonical_name;
+    };
+
+    static const id_class_ id;
+
+    // location
+    //
+    struct location_class_
+    {
+      location_class_ ()
+      {
+      }
+
+      // url
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      url_type_;
+
+      static const url_type_ url;
+
+      // type
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      type_type_;
+
+      static const type_type_ type;
+    };
+
+    static const location_class_ location;
+
+    // display_name
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    display_name_type_;
+
+    static const display_name_type_ display_name;
+
+    // priority
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint16_t,
+        pgsql::id_integer >::query_type,
+      pgsql::id_integer >
+    priority_type_;
+
+    static const priority_type_ priority;
+
+    // interface_url
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    interface_url_type_;
+
+    static const interface_url_type_ interface_url;
+
+    // email
+    //
+    struct email_class_
+    {
+      email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const email_class_ email;
+
+    // summary
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    summary_type_;
+
+    static const summary_type_ summary;
+
+    // description
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    description_type_;
+
+    static const description_type_ description;
+
+    // cache_location
+    //
+    struct cache_location_class_
+    {
+      cache_location_class_ ()
+      {
+      }
+
+      // url
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      url_type_;
+
+      static const url_type_ url;
+
+      // type
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      type_type_;
+
+      static const type_type_ type;
+    };
+
+    static const cache_location_class_ cache_location;
+
+    // certificate
+    //
+    struct certificate_class_
+    {
+      certificate_class_ ()
+      {
+      }
+
+      // fingerprint
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      fingerprint_type_;
+
+      static const fingerprint_type_ fingerprint;
+
+      // name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      name_type_;
+
+      static const name_type_ name;
+
+      // organization
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      organization_type_;
+
+      static const organization_type_ organization;
+
+      // email
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      email_type_;
+
+      static const email_type_ email;
+
+      // pem
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      pem_type_;
+
+      static const pem_type_ pem;
+    };
+
+    static const certificate_class_ certificate;
+
+    // packages_timestamp
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint64_t,
+        pgsql::id_bigint >::query_type,
+      pgsql::id_bigint >
+    packages_timestamp_type_;
+
+    static const packages_timestamp_type_ packages_timestamp;
+
+    // repositories_timestamp
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::uint64_t,
+        pgsql::id_bigint >::query_type,
+      pgsql::id_bigint >
+    repositories_timestamp_type_;
+
+    static const repositories_timestamp_type_ repositories_timestamp;
+
+    // internal
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    internal_type_;
+
+    static const internal_type_ internal;
+
+    // buildable
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    buildable_type_;
+
+    static const buildable_type_ buildable;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::id_class_::tenant_type_
+  query_columns< ::brep::repository, id_pgsql, A >::id_class_::
+  tenant (A::table_name, "\"tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::id_class_::canonical_name_type_
+  query_columns< ::brep::repository, id_pgsql, A >::id_class_::
+  canonical_name (A::table_name, "\"canonical_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::id_class_
+  query_columns< ::brep::repository, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::location_class_::url_type_
+  query_columns< ::brep::repository, id_pgsql, A >::location_class_::
+  url (A::table_name, "\"location_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::location_class_::type_type_
+  query_columns< ::brep::repository, id_pgsql, A >::location_class_::
+  type (A::table_name, "\"location_type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::location_class_
+  query_columns< ::brep::repository, id_pgsql, A >::location;
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::display_name_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  display_name (A::table_name, "\"display_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::priority_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  priority (A::table_name, "\"priority\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::interface_url_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  interface_url (A::table_name, "\"interface_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::email_class_::value_type_
+  query_columns< ::brep::repository, id_pgsql, A >::email_class_::
+  value (A::table_name, "\"email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::email_class_::comment_type_
+  query_columns< ::brep::repository, id_pgsql, A >::email_class_::
+  comment (A::table_name, "\"email_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::email_class_
+  query_columns< ::brep::repository, id_pgsql, A >::email;
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::summary_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  summary (A::table_name, "\"summary\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::description_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  description (A::table_name, "\"description\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::url_type_
+  query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::
+  url (A::table_name, "\"cache_location_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::type_type_
+  query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::
+  type (A::table_name, "\"cache_location_type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_
+  query_columns< ::brep::repository, id_pgsql, A >::cache_location;
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::fingerprint_type_
+  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
+  fingerprint (A::table_name, "\"certificate_fingerprint\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::name_type_
+  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
+  name (A::table_name, "\"certificate_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::organization_type_
+  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
+  organization (A::table_name, "\"certificate_organization\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::email_type_
+  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
+  email (A::table_name, "\"certificate_email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::pem_type_
+  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
+  pem (A::table_name, "\"certificate_pem\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_
+  query_columns< ::brep::repository, id_pgsql, A >::certificate;
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::packages_timestamp_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  packages_timestamp (A::table_name, "\"packages_timestamp\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::repositories_timestamp_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  repositories_timestamp (A::table_name, "\"repositories_timestamp\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::internal_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  internal (A::table_name, "\"internal\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::repository, id_pgsql, A >::buildable_type_
+  query_columns< ::brep::repository, id_pgsql, A >::
+  buildable (A::table_name, "\"buildable\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::brep::repository, id_pgsql, A >:
+    query_columns< ::brep::repository, id_pgsql, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::repository, id_pgsql >:
+    public access::object_traits< ::brep::repository >
+  {
+    public:
+    struct id_image_type
+    {
+      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type id_value;
+
+      // location
+      //
+      composite_value_traits< ::brep::_repository_location, id_pgsql >::image_type location_value;
+
+      // display_name
+      //
+      details::buffer display_name_value;
+      std::size_t display_name_size;
+      bool display_name_null;
+
+      // priority
+      //
+      int priority_value;
+      bool priority_null;
+
+      // interface_url
+      //
+      details::buffer interface_url_value;
+      std::size_t interface_url_size;
+      bool interface_url_null;
+
+      // email
+      //
+      composite_value_traits< ::bpkg::email, id_pgsql >::image_type email_value;
+
+      // summary
+      //
+      details::buffer summary_value;
+      std::size_t summary_size;
+      bool summary_null;
+
+      // description
+      //
+      details::buffer description_value;
+      std::size_t description_size;
+      bool description_null;
+
+      // cache_location
+      //
+      composite_value_traits< ::brep::_repository_location, id_pgsql >::image_type cache_location_value;
+
+      // certificate
+      //
+      composite_value_traits< ::brep::certificate, id_pgsql >::image_type certificate_value;
+
+      // packages_timestamp
+      //
+      long long packages_timestamp_value;
+      bool packages_timestamp_null;
+
+      // repositories_timestamp
+      //
+      long long repositories_timestamp_value;
+      bool repositories_timestamp_null;
+
+      // internal
+      //
+      bool internal_value;
+      bool internal_null;
+
+      // buildable
+      //
+      bool buildable_value;
+      bool buildable_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // complements
+    //
+    struct complements_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 2UL;
+      static const std::size_t data_column_count = 5UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< complements_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< ::brep::repository_id, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // prerequisites
+    //
+    struct prerequisites_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 2UL;
+      static const std::size_t data_column_count = 5UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< prerequisites_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< ::brep::repository_id, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 22UL;
+    static const std::size_t id_column_count = 2UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char update_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+    static const unsigned int update_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::repository, id_common >:
+    public access::object_traits_impl< ::brep::repository, id_pgsql >
+  {
+  };
+
+  // _license_key
+  //
+  template <>
+  class access::composite_value_traits< ::brep::package::_license_key, id_pgsql >
+  {
+    public:
+    typedef ::brep::package::_license_key value_type;
+
+    struct image_type
+    {
+      // outer
+      //
+      long long outer_value;
+      bool outer_null;
+
+      // inner
+      //
+      long long inner_value;
+      bool inner_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // _dependency_key
+  //
+  template <>
+  class access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >
+  {
+    public:
+    typedef ::brep::package::_dependency_key value_type;
+
+    struct image_type
+    {
+      // outer
+      //
+      long long outer_value;
+      bool outer_null;
+
+      // inner
+      //
+      long long inner_value;
+      bool inner_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // _requirement_key
+  //
+  template <>
+  class access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >
+  {
+    public:
+    typedef ::brep::package::_requirement_key value_type;
+
+    struct image_type
+    {
+      // outer
+      //
+      long long outer_value;
+      bool outer_null;
+
+      // inner
+      //
+      long long inner_value;
+      bool inner_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              pgsql::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // package
+  //
+  template <typename A>
+  struct pointer_query_columns< ::brep::package, id_pgsql, A >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      name_type_;
+
+      static const name_type_ name;
+
+      // version
+      //
+      struct version_class_1_
+      {
+        version_class_1_ ()
+        {
+        }
+
+        // epoch
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        epoch_type_;
+
+        static const epoch_type_ epoch;
+
+        // canonical_upstream
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_upstream_type_;
+
+        static const canonical_upstream_type_ canonical_upstream;
+
+        // canonical_release
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_release_type_;
+
+        static const canonical_release_type_ canonical_release;
+
+        // revision
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        revision_type_;
+
+        static const revision_type_ revision;
+      };
+
+      static const version_class_1_ version;
+    };
+
+    static const id_class_ id;
+
+    // version
+    //
+    struct version_class_
+    {
+      version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const version_class_ version;
+
+    // upstream_version
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    upstream_version_type_;
+
+    static const upstream_version_type_ upstream_version;
+
+    // project
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::bpkg::package_name,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    project_type_;
+
+    static const project_type_ project;
+
+    // priority
+    //
+    struct priority_class_
+    {
+      priority_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::bpkg::priority::value_type,
+          pgsql::id_integer >::query_type,
+        pgsql::id_integer >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const priority_class_ priority;
+
+    // summary
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    summary_type_;
+
+    static const summary_type_ summary;
+
+    // description
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    description_type_;
+
+    static const description_type_ description;
+
+    // description_type
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    description_type_type_;
+
+    static const description_type_type_ description_type;
+
+    // changes
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    changes_type_;
+
+    static const changes_type_ changes;
+
+    // url
+    //
+    struct url_class_
+    {
+      url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const url_class_ url;
+
+    // doc_url
+    //
+    struct doc_url_class_
+    {
+      doc_url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const doc_url_class_ doc_url;
+
+    // src_url
+    //
+    struct src_url_class_
+    {
+      src_url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const src_url_class_ src_url;
+
+    // package_url
+    //
+    struct package_url_class_
+    {
+      package_url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const package_url_class_ package_url;
+
+    // email
+    //
+    struct email_class_
+    {
+      email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const email_class_ email;
+
+    // package_email
+    //
+    struct package_email_class_
+    {
+      package_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const package_email_class_ package_email;
+
+    // build_email
+    //
+    struct build_email_class_
+    {
+      build_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const build_email_class_ build_email;
+
+    // build_warning_email
+    //
+    struct build_warning_email_class_
+    {
+      build_warning_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const build_warning_email_class_ build_warning_email;
+
+    // build_error_email
+    //
+    struct build_error_email_class_
+    {
+      build_error_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const build_error_email_class_ build_error_email;
+
+    // internal_repository
+    //
+    struct internal_repository_class_
+    {
+      internal_repository_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // canonical_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      canonical_name_type_;
+
+      static const canonical_name_type_ canonical_name;
+    };
+
+    static const internal_repository_class_ internal_repository;
+
+    // location
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    location_type_;
+
+    static const location_type_ location;
+
+    // fragment
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    fragment_type_;
+
+    static const fragment_type_ fragment;
+
+    // sha256sum
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    sha256sum_type_;
+
+    static const sha256sum_type_ sha256sum;
+
+    // buildable
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    buildable_type_;
+
+    static const buildable_type_ buildable;
+
+    // unbuildable_reason
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    unbuildable_reason_type_;
+
+    static const unbuildable_reason_type_ unbuildable_reason;
+
+    // search_index
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::brep::weighted_text,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    search_index_type_;
+
+    static const search_index_type_ search_index;
+  };
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::tenant_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::
+  tenant (A::table_name, "\"tenant\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::name_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::
+  name (A::table_name, "\"name\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::epoch_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  epoch (A::table_name, "\"version_epoch\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_upstream_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_release_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_release (A::table_name, "\"version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::revision_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  revision (A::table_name, "\"version_revision\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::upstream_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::
+  upstream (A::table_name, "\"version_upstream\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::release_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::
+  release (A::table_name, "\"version_release\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::version;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::upstream_version_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  upstream_version (A::table_name, "\"upstream_version\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::project_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  project (A::table_name, "\"project\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::
+  value (A::table_name, "\"priority\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::
+  comment (A::table_name, "\"priority_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::priority;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::summary_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  summary (A::table_name, "\"summary\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::description_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  description (A::table_name, "\"description\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::description_type_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  description_type (A::table_name, "\"description_type\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::changes_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  changes (A::table_name, "\"changes\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::
+  value (A::table_name, "\"url\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::
+  comment (A::table_name, "\"url_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::url;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
+  value (A::table_name, "\"doc_url\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
+  comment (A::table_name, "\"doc_url_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
+  value (A::table_name, "\"src_url\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
+  comment (A::table_name, "\"src_url_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::src_url;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
+  value (A::table_name, "\"package_url\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
+  comment (A::table_name, "\"package_url_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::package_url;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::
+  value (A::table_name, "\"email\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::
+  comment (A::table_name, "\"email_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::email;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
+  value (A::table_name, "\"package_email\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
+  comment (A::table_name, "\"package_email_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::package_email;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
+  value (A::table_name, "\"build_email\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
+  comment (A::table_name, "\"build_email_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_email;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
+  value (A::table_name, "\"build_warning_email\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
+  comment (A::table_name, "\"build_warning_email_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::value_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
+  value (A::table_name, "\"build_error_email\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::comment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
+  comment (A::table_name, "\"build_error_email_comment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::tenant_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::
+  tenant (A::table_name, "\"internal_repository_tenant\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::canonical_name_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::
+  canonical_name (A::table_name, "\"internal_repository_canonical_name\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository;
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::location_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  location (A::table_name, "\"location\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::fragment_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  fragment (A::table_name, "\"fragment\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::sha256sum_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  sha256sum (A::table_name, "\"sha256sum\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::buildable_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  buildable (A::table_name, "\"buildable\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::unbuildable_reason_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  unbuildable_reason (A::table_name, "\"unbuildable_reason\"", 0);
+
+  template <typename A>
+  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::search_index_type_
+  pointer_query_columns< ::brep::package, id_pgsql, A >::
+  search_index (A::table_name, "\"search_index\"", "to_tsvector((?)::weighted_text)");
+
+  template <>
+  class access::object_traits_impl< ::brep::package, id_pgsql >:
+    public access::object_traits< ::brep::package >
+  {
+    public:
+    struct id_image_type
+    {
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      // version
+      //
+      composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::image_type version_value;
+
+      // upstream_version
+      //
+      details::buffer upstream_version_value;
+      std::size_t upstream_version_size;
+      bool upstream_version_null;
+
+      // project
+      //
+      details::buffer project_value;
+      std::size_t project_size;
+      bool project_null;
+
+      // priority
+      //
+      composite_value_traits< ::brep::package::priority_type, id_pgsql >::image_type priority_value;
+
+      // summary
+      //
+      details::buffer summary_value;
+      std::size_t summary_size;
+      bool summary_null;
+
+      // description
+      //
+      details::buffer description_value;
+      std::size_t description_size;
+      bool description_null;
+
+      // description_type
+      //
+      details::buffer description_type_value;
+      std::size_t description_type_size;
+      bool description_type_null;
+
+      // changes
+      //
+      details::buffer changes_value;
+      std::size_t changes_size;
+      bool changes_null;
+
+      // url
+      //
+      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type url_value;
+
+      // doc_url
+      //
+      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type doc_url_value;
+
+      // src_url
+      //
+      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type src_url_value;
+
+      // package_url
+      //
+      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type package_url_value;
+
+      // email
+      //
+      composite_value_traits< ::bpkg::email, id_pgsql >::image_type email_value;
+
+      // package_email
+      //
+      composite_value_traits< ::bpkg::email, id_pgsql >::image_type package_email_value;
+
+      // build_email
+      //
+      composite_value_traits< ::bpkg::email, id_pgsql >::image_type build_email_value;
+
+      // build_warning_email
+      //
+      composite_value_traits< ::bpkg::email, id_pgsql >::image_type build_warning_email_value;
+
+      // build_error_email
+      //
+      composite_value_traits< ::bpkg::email, id_pgsql >::image_type build_error_email_value;
+
+      // internal_repository
+      //
+      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type internal_repository_value;
+
+      // location
+      //
+      details::buffer location_value;
+      std::size_t location_size;
+      bool location_null;
+
+      // fragment
+      //
+      details::buffer fragment_value;
+      std::size_t fragment_size;
+      bool fragment_null;
+
+      // sha256sum
+      //
+      details::buffer sha256sum_value;
+      std::size_t sha256sum_size;
+      bool sha256sum_null;
+
+      // buildable
+      //
+      bool buildable_value;
+      bool buildable_null;
+
+      // unbuildable_reason
+      //
+      details::buffer unbuildable_reason_value;
+      std::size_t unbuildable_reason_size;
+      bool unbuildable_reason_null;
+
+      // search_index
+      //
+      details::buffer search_index_value;
+      std::size_t search_index_size;
+      bool search_index_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // license_alternatives
+    //
+    struct license_alternatives_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 8UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::brep::package::license_alternatives_type container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< license_alternatives_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // licenses
+    //
+    struct licenses_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::key_type key_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef map_functions<key_type, value_type> functions_type;
+      typedef pgsql::container_statements< licenses_traits > statements_type;
+
+      struct data_image_type
+      {
+        // key
+        //
+        composite_value_traits< key_type, id_pgsql >::image_type key_value;
+
+        // value
+        //
+        details::buffer value_value;
+        std::size_t value_size;
+        bool value_null;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const key_type*,
+            const value_type&);
+
+      static void
+      init (key_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const key_type&, const value_type&, void*);
+
+      static bool
+      select (key_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // topics
+    //
+    struct topics_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 8UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::butl::small_vector< ::std::basic_string< char >, 5 > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< topics_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        details::buffer value_value;
+        std::size_t value_size;
+        bool value_null;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // keywords
+    //
+    struct keywords_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 8UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::butl::small_vector< ::std::basic_string< char >, 5 > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< keywords_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        details::buffer value_value;
+        std::size_t value_size;
+        bool value_null;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // dependencies
+    //
+    struct dependencies_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 10UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::brep::package::dependencies_type container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< dependencies_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // dependency_alternatives
+    //
+    struct dependency_alternatives_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 29UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::key_type key_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef map_functions<key_type, value_type> functions_type;
+      typedef pgsql::container_statements< dependency_alternatives_traits > statements_type;
+
+      struct data_image_type
+      {
+        // key
+        //
+        composite_value_traits< key_type, id_pgsql >::image_type key_value;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const key_type*,
+            const value_type&);
+
+      static void
+      init (key_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const key_type&, const value_type&, void*);
+
+      static bool
+      select (key_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // requirements
+    //
+    struct requirements_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 10UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::brep::package::requirements_type container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< requirements_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // requirement_alternatives
+    //
+    struct requirement_alternatives_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::key_type key_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef map_functions<key_type, value_type> functions_type;
+      typedef pgsql::container_statements< requirement_alternatives_traits > statements_type;
+
+      struct data_image_type
+      {
+        // key
+        //
+        composite_value_traits< key_type, id_pgsql >::image_type key_value;
+
+        // value
+        //
+        details::buffer value_value;
+        std::size_t value_size;
+        bool value_null;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const key_type*,
+            const value_type&);
+
+      static void
+      init (key_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const key_type&, const value_type&, void*);
+
+      static bool
+      select (key_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // tests
+    //
+    struct tests_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 29UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::butl::small_vector< ::brep::test_dependency, 1 > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< tests_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // builds
+    //
+    struct builds_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::brep::build_class_exprs container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< builds_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // build_constraints
+    //
+    struct build_constraints_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 11UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::brep::package::build_constraints_type container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< build_constraints_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // other_repositories
+    //
+    struct other_repositories_traits
+    {
+      static const char select_name[];
+      static const char insert_name[];
+      static const char delete_name[];
+
+      static const unsigned int insert_types[];
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef pgsql::container_statements< other_repositories_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< ::brep::repository_id, id_pgsql >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (pgsql::bind*,
+            const pgsql::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // build_section
+    //
+    struct build_section_traits
+    {
+      typedef object_traits_impl<object_type, id_pgsql>::image_type image_type;
+      typedef object_traits_impl<object_type, id_pgsql>::id_image_type id_image_type;
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t managed_optimistic_load_column_count = 0UL;
+      static const std::size_t load_column_count = 0UL;
+      static const std::size_t managed_optimistic_update_column_count = 0UL;
+      static const std::size_t update_column_count = 0UL;
+
+      static const bool versioned = false;
+
+      static void
+      load (extra_statement_cache_type&, object_type&);
+
+      static void
+      update (extra_statement_cache_type&, const object_type&);
+    };
+
+    struct internal_repository_tag;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&,
+          pgsql::statement_kind);
+
+    static void
+    bind (pgsql::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          pgsql::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef pgsql::object_statements<object_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+
+    static const std::size_t column_count = 42UL;
+    static const std::size_t id_column_count = 6UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static bool
+    load (connection&, object_type&, section&);
+
+    static bool
+    update (connection&, const object_type&, const section&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char persist_statement_name[];
+    static const char find_statement_name[];
+    static const char update_statement_name[];
+    static const char erase_statement_name[];
+    static const char query_statement_name[];
+    static const char erase_query_statement_name[];
+
+    static const unsigned int persist_statement_types[];
+    static const unsigned int find_statement_types[];
+    static const unsigned int update_statement_types[];
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::brep::package, id_common >:
+    public access::object_traits_impl< ::brep::package, id_pgsql >
+  {
+  };
+
+  // latest_package_search_rank
+  //
+  template <>
+  class access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:
+    public access::view_traits< ::brep::latest_package_search_rank >
+  {
+    public:
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      // rank
+      //
+      double rank_value;
+      bool rank_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns
+    {
+    };
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 7UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::latest_package_search_rank, id_common >:
+    public access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >
+  {
+  };
+
+  // latest_package_count
+  //
+  template <>
+  class access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:
+    public access::view_traits< ::brep::latest_package_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns
+    {
+    };
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::latest_package_count, id_common >:
+    public access::view_traits_impl< ::brep::latest_package_count, id_pgsql >
+  {
+  };
+
+  // package_search_rank
+  //
+  template <>
+  class access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:
+    public access::view_traits< ::brep::package_search_rank >
+  {
+    public:
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      // rank
+      //
+      double rank_value;
+      bool rank_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns
+    {
+    };
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 7UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::package_search_rank, id_common >:
+    public access::view_traits_impl< ::brep::package_search_rank, id_pgsql >
+  {
+  };
+
+  // package_count
+  //
+  template <>
+  class access::view_traits_impl< ::brep::package_count, id_pgsql >:
+    public access::view_traits< ::brep::package_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns
+    {
+    };
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::package_count, id_common >:
+    public access::view_traits_impl< ::brep::package_count, id_pgsql >
+  {
+  };
+
+  // latest_package
+  //
+  template <>
+  class access::view_traits_impl< ::brep::latest_package, id_pgsql >:
+    public access::view_traits< ::brep::latest_package >
+  {
+    public:
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    typedef pgsql::view_statements<view_type> statements_type;
+
+    typedef pgsql::query_base query_base_type;
+    struct query_columns
+    {
+    };
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (pgsql::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 6UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    static const char query_statement_name[];
+  };
+
+  template <>
+  class access::view_traits_impl< ::brep::latest_package, id_common >:
+    public access::view_traits_impl< ::brep::latest_package, id_pgsql >
+  {
+  };
+
+  // tenant
+  //
+  // tenant_id
+  //
+  struct access::view_traits_impl< ::brep::tenant_id, id_pgsql >::query_columns:
+    odb::pointer_query_columns<
+      ::brep::tenant,
+      id_pgsql,
+      odb::access::object_traits_impl< ::brep::tenant, id_pgsql > >
+  {
+  };
+
+  // repository
+  //
+  // package
+  //
+  template <>
+  struct alias_traits<
+    ::brep::repository,
+    id_pgsql,
+    access::object_traits_impl< ::brep::package, id_pgsql >::internal_repository_tag>
+  {
+    static const char table_name[];
+  };
+
+  template <>
+  struct query_columns_base< ::brep::package, id_pgsql >
+  {
+    // internal_repository
+    //
+    typedef
+    odb::alias_traits<
+      ::brep::repository,
+      id_pgsql,
+      access::object_traits_impl< ::brep::package, id_pgsql >::internal_repository_tag>
+    internal_repository_alias_;
+  };
+
+  template <typename A>
+  struct query_columns< ::brep::package, id_pgsql, A >:
+    query_columns_base< ::brep::package, id_pgsql >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::bpkg::package_name,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      name_type_;
+
+      static const name_type_ name;
+
+      // version
+      //
+      struct version_class_1_
+      {
+        version_class_1_ ()
+        {
+        }
+
+        // epoch
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        epoch_type_;
+
+        static const epoch_type_ epoch;
+
+        // canonical_upstream
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_upstream_type_;
+
+        static const canonical_upstream_type_ canonical_upstream;
+
+        // canonical_release
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::std::string,
+            pgsql::id_string >::query_type,
+          pgsql::id_string >
+        canonical_release_type_;
+
+        static const canonical_release_type_ canonical_release;
+
+        // revision
+        //
+        typedef
+        pgsql::query_column<
+          pgsql::value_traits<
+            ::uint16_t,
+            pgsql::id_integer >::query_type,
+          pgsql::id_integer >
+        revision_type_;
+
+        static const revision_type_ revision;
+      };
+
+      static const version_class_1_ version;
+    };
+
+    static const id_class_ id;
+
+    // version
+    //
+    struct version_class_
+    {
+      version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::basic_string< char >,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const version_class_ version;
+
+    // upstream_version
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    upstream_version_type_;
+
+    static const upstream_version_type_ upstream_version;
+
+    // project
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::bpkg::package_name,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    project_type_;
+
+    static const project_type_ project;
+
+    // priority
+    //
+    struct priority_class_
+    {
+      priority_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::bpkg::priority::value_type,
+          pgsql::id_integer >::query_type,
+        pgsql::id_integer >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const priority_class_ priority;
+
+    // summary
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    summary_type_;
+
+    static const summary_type_ summary;
+
+    // description
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    description_type_;
+
+    static const description_type_ description;
+
+    // description_type
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    description_type_type_;
+
+    static const description_type_type_ description_type;
+
+    // changes
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::string,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    changes_type_;
+
+    static const changes_type_ changes;
+
+    // url
+    //
+    struct url_class_
+    {
+      url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const url_class_ url;
+
+    // doc_url
+    //
+    struct doc_url_class_
+    {
+      doc_url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const doc_url_class_ doc_url;
+
+    // src_url
+    //
+    struct src_url_class_
+    {
+      src_url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const src_url_class_ src_url;
+
+    // package_url
+    //
+    struct package_url_class_
+    {
+      package_url_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const package_url_class_ package_url;
+
+    // email
+    //
+    struct email_class_
+    {
+      email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const email_class_ email;
+
+    // package_email
+    //
+    struct package_email_class_
+    {
+      package_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const package_email_class_ package_email;
+
+    // build_email
+    //
+    struct build_email_class_
+    {
+      build_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const build_email_class_ build_email;
+
+    // build_warning_email
+    //
+    struct build_warning_email_class_
+    {
+      build_warning_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const build_warning_email_class_ build_warning_email;
+
+    // build_error_email
+    //
+    struct build_error_email_class_
+    {
+      build_error_email_class_ ()
+      {
+      }
+
+      // value
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      value_type_;
+
+      static const value_type_ value;
+
+      // comment
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      comment_type_;
+
+      static const comment_type_ comment;
+    };
+
+    static const build_error_email_class_ build_error_email;
+
+    // internal_repository
+    //
+    struct internal_repository_column_class_
+    {
+      internal_repository_column_class_ ()
+      {
+      }
+
+      // tenant
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      tenant_type_;
+
+      static const tenant_type_ tenant;
+
+      // canonical_name
+      //
+      typedef
+      pgsql::query_column<
+        pgsql::value_traits<
+          ::std::string,
+          pgsql::id_string >::query_type,
+        pgsql::id_string >
+      canonical_name_type_;
+
+      static const canonical_name_type_ canonical_name;
+    };
+
+    typedef
+    odb::query_pointer<
+      odb::pointer_query_columns<
+        ::brep::repository,
+        id_pgsql,
+        internal_repository_alias_ > >
+    internal_repository_pointer_type_;
+
+    struct internal_repository_type_: internal_repository_pointer_type_, internal_repository_column_class_
+    {
+      internal_repository_type_ ()
+      {
+      }
+    };
+
+    static const internal_repository_type_ internal_repository;
+
+    // location
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    location_type_;
+
+    static const location_type_ location;
+
+    // fragment
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    fragment_type_;
+
+    static const fragment_type_ fragment;
+
+    // sha256sum
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    sha256sum_type_;
+
+    static const sha256sum_type_ sha256sum;
+
+    // buildable
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        bool,
+        pgsql::id_boolean >::query_type,
+      pgsql::id_boolean >
+    buildable_type_;
+
+    static const buildable_type_ buildable;
+
+    // unbuildable_reason
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::std::basic_string< char >,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    unbuildable_reason_type_;
+
+    static const unbuildable_reason_type_ unbuildable_reason;
+
+    // search_index
+    //
+    typedef
+    pgsql::query_column<
+      pgsql::value_traits<
+        ::brep::weighted_text,
+        pgsql::id_string >::query_type,
+      pgsql::id_string >
+    search_index_type_;
+
+    static const search_index_type_ search_index;
+  };
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::tenant_type_
+  query_columns< ::brep::package, id_pgsql, A >::id_class_::
+  tenant (A::table_name, "\"tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::name_type_
+  query_columns< ::brep::package, id_pgsql, A >::id_class_::
+  name (A::table_name, "\"name\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::epoch_type_
+  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  epoch (A::table_name, "\"version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_upstream_type_
+  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_release_type_
+  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  canonical_release (A::table_name, "\"version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::revision_type_
+  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
+  revision (A::table_name, "\"version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_
+  query_columns< ::brep::package, id_pgsql, A >::id_class_::version;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_
+  query_columns< ::brep::package, id_pgsql, A >::id;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::version_class_::upstream_type_
+  query_columns< ::brep::package, id_pgsql, A >::version_class_::
+  upstream (A::table_name, "\"version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::version_class_::release_type_
+  query_columns< ::brep::package, id_pgsql, A >::version_class_::
+  release (A::table_name, "\"version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::version_class_
+  query_columns< ::brep::package, id_pgsql, A >::version;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::upstream_version_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  upstream_version (A::table_name, "\"upstream_version\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::project_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  project (A::table_name, "\"project\"", "(?)::CITEXT");
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::priority_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::priority_class_::
+  value (A::table_name, "\"priority\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::priority_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::priority_class_::
+  comment (A::table_name, "\"priority_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::priority_class_
+  query_columns< ::brep::package, id_pgsql, A >::priority;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::summary_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  summary (A::table_name, "\"summary\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::description_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  description (A::table_name, "\"description\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::description_type_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  description_type (A::table_name, "\"description_type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::changes_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  changes (A::table_name, "\"changes\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::url_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::url_class_::
+  value (A::table_name, "\"url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::url_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::url_class_::
+  comment (A::table_name, "\"url_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::url_class_
+  query_columns< ::brep::package, id_pgsql, A >::url;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
+  value (A::table_name, "\"doc_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
+  comment (A::table_name, "\"doc_url_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::doc_url_class_
+  query_columns< ::brep::package, id_pgsql, A >::doc_url;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::src_url_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
+  value (A::table_name, "\"src_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::src_url_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
+  comment (A::table_name, "\"src_url_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::src_url_class_
+  query_columns< ::brep::package, id_pgsql, A >::src_url;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::package_url_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
+  value (A::table_name, "\"package_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::package_url_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
+  comment (A::table_name, "\"package_url_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::package_url_class_
+  query_columns< ::brep::package, id_pgsql, A >::package_url;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::email_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::email_class_::
+  value (A::table_name, "\"email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::email_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::email_class_::
+  comment (A::table_name, "\"email_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::email_class_
+  query_columns< ::brep::package, id_pgsql, A >::email;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::package_email_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
+  value (A::table_name, "\"package_email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::package_email_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
+  comment (A::table_name, "\"package_email_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::package_email_class_
+  query_columns< ::brep::package, id_pgsql, A >::package_email;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_email_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
+  value (A::table_name, "\"build_email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_email_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
+  comment (A::table_name, "\"build_email_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_email_class_
+  query_columns< ::brep::package, id_pgsql, A >::build_email;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
+  value (A::table_name, "\"build_warning_email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
+  comment (A::table_name, "\"build_warning_email_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_
+  query_columns< ::brep::package, id_pgsql, A >::build_warning_email;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::value_type_
+  query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
+  value (A::table_name, "\"build_error_email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::comment_type_
+  query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
+  comment (A::table_name, "\"build_error_email_comment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_
+  query_columns< ::brep::package, id_pgsql, A >::build_error_email;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::tenant_type_
+  query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::
+  tenant (A::table_name, "\"internal_repository_tenant\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::canonical_name_type_
+  query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::
+  canonical_name (A::table_name, "\"internal_repository_canonical_name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::internal_repository_type_
+  query_columns< ::brep::package, id_pgsql, A >::internal_repository;
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::location_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  location (A::table_name, "\"location\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::fragment_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  fragment (A::table_name, "\"fragment\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::sha256sum_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  sha256sum (A::table_name, "\"sha256sum\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::buildable_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  buildable (A::table_name, "\"buildable\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::unbuildable_reason_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  unbuildable_reason (A::table_name, "\"unbuildable_reason\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::brep::package, id_pgsql, A >::search_index_type_
+  query_columns< ::brep::package, id_pgsql, A >::
+  search_index (A::table_name, "\"search_index\"", "to_tsvector((?)::weighted_text)");
+}
+
+#include <libbrep/package-odb.ixx>
+
+#include <odb/post.hxx>
+
+#endif // LIBBREP_PACKAGE_ODB_HXX
diff --git a/libbrep/package-odb.ixx b/libbrep/package-odb.ixx
new file mode 100644
index 0000000..0e1f85b
--- /dev/null
+++ b/libbrep/package-odb.ixx
@@ -0,0 +1,587 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+namespace odb
+{
+  // tenant
+  //
+
+  inline
+  access::object_traits< ::brep::tenant >::id_type
+  access::object_traits< ::brep::tenant >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::tenant >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::tenant >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // tenant_id
+  //
+
+  inline
+  void access::view_traits< ::brep::tenant_id >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository
+  //
+
+  inline
+  access::object_traits< ::brep::repository >::id_type
+  access::object_traits< ::brep::repository >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::repository >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::repository >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // package
+  //
+
+  inline
+  access::object_traits< ::brep::package >::id_type
+  access::object_traits< ::brep::package >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::brep::package >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::brep::package >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // latest_package_search_rank
+  //
+
+  inline
+  void access::view_traits< ::brep::latest_package_search_rank >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // latest_package_count
+  //
+
+  inline
+  void access::view_traits< ::brep::latest_package_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // package_search_rank
+  //
+
+  inline
+  void access::view_traits< ::brep::package_search_rank >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // package_count
+  //
+
+  inline
+  void access::view_traits< ::brep::package_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // latest_package
+  //
+
+  inline
+  void access::view_traits< ::brep::latest_package >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+}
+
+namespace odb
+{
+  // priority
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::priority, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.value_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::priority, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.value_null = true;
+    i.comment_null = true;
+  }
+
+  // licenses
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::licenses, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::licenses, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.comment_null = true;
+  }
+
+  // manifest_url
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.value_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.value_null = true;
+    i.comment_null = true;
+  }
+
+  // email
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::email, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.value_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::email, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.value_null = true;
+    i.comment_null = true;
+  }
+
+  // version_constraint
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && composite_value_traits< ::brep::_version, id_pgsql >::get_null (i.min_version_value);
+    r = r && composite_value_traits< ::brep::_version, id_pgsql >::get_null (i.max_version_value);
+    r = r && i.min_open_null;
+    r = r && i.max_open_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    composite_value_traits< ::brep::_version, id_pgsql >::set_null (i.min_version_value, sk);
+    composite_value_traits< ::brep::_version, id_pgsql >::set_null (i.max_version_value, sk);
+    i.min_open_null = true;
+    i.max_open_null = true;
+  }
+
+  // requirement_alternatives
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.conditional_null;
+    r = r && i.buildtime_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.conditional_null = true;
+    i.buildtime_null = true;
+    i.comment_null = true;
+  }
+
+  // dependency
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::dependency, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.name_null;
+    r = r && composite_value_traits< ::bpkg::version_constraint, id_pgsql >::get_null (i.constraint_value);
+    r = r && composite_value_traits< ::brep::package_id, id_pgsql >::get_null (i.package_value);
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::dependency, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.name_null = true;
+    composite_value_traits< ::bpkg::version_constraint, id_pgsql >::set_null (i.constraint_value, sk);
+    composite_value_traits< ::brep::package_id, id_pgsql >::set_null (i.package_value, sk);
+  }
+
+  // dependency_alternatives
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.conditional_null;
+    r = r && i.buildtime_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.conditional_null = true;
+    i.buildtime_null = true;
+    i.comment_null = true;
+  }
+
+  // test_dependency
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::test_dependency, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && composite_value_traits< ::brep::dependency, id_pgsql >::get_null (i);
+    r = r && i.type_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::test_dependency, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    composite_value_traits< ::brep::dependency, id_pgsql >::set_null (i, sk);
+    i.type_null = true;
+  }
+
+  // certificate
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::certificate, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.fingerprint_null;
+    r = r && i.name_null;
+    r = r && i.organization_null;
+    r = r && i.email_null;
+    r = r && i.pem_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::certificate, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.fingerprint_null = true;
+    i.name_null = true;
+    i.organization_null = true;
+    i.email_null = true;
+    i.pem_null = true;
+  }
+
+  // tenant
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  inline
+  void access::object_traits_impl< ::brep::tenant, id_pgsql >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool)
+  {
+    ODB_POTENTIALLY_UNUSED (sts);
+    ODB_POTENTIALLY_UNUSED (obj);
+  }
+
+  // tenant_id
+  //
+
+  // repository
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::repository, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // _license_key
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::package::_license_key, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.outer_null;
+    r = r && i.inner_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::package::_license_key, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.outer_null = true;
+    i.inner_null = true;
+  }
+
+  // _dependency_key
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.outer_null;
+    r = r && i.inner_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.outer_null = true;
+    i.inner_null = true;
+  }
+
+  // _requirement_key
+  //
+
+  inline
+  bool access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.outer_null;
+    r = r && i.inner_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >::
+  set_null (image_type& i,
+            pgsql::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace pgsql;
+
+    i.outer_null = true;
+    i.inner_null = true;
+  }
+
+  // package
+  //
+
+  inline
+  void access::object_traits_impl< ::brep::package, id_pgsql >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // latest_package_search_rank
+  //
+
+  // latest_package_count
+  //
+
+  // package_search_rank
+  //
+
+  // package_count
+  //
+
+  // latest_package
+  //
+}
+
diff --git a/libbrep/package.sql b/libbrep/package.sql
new file mode 100644
index 0000000..1c01986
--- /dev/null
+++ b/libbrep/package.sql
@@ -0,0 +1,791 @@
+/* This file was generated by ODB, object-relational mapping (ORM)
+ * compiler for C++.
+ */
+
+DROP TABLE IF EXISTS "package_other_repositories" CASCADE;
+
+DROP TABLE IF EXISTS "package_build_constraints" CASCADE;
+
+DROP TABLE IF EXISTS "package_builds" CASCADE;
+
+DROP TABLE IF EXISTS "package_tests" CASCADE;
+
+DROP TABLE IF EXISTS "package_requirement_alternatives" CASCADE;
+
+DROP TABLE IF EXISTS "package_requirements" CASCADE;
+
+DROP TABLE IF EXISTS "package_dependency_alternatives" CASCADE;
+
+DROP TABLE IF EXISTS "package_dependencies" CASCADE;
+
+DROP TABLE IF EXISTS "package_keywords" CASCADE;
+
+DROP TABLE IF EXISTS "package_topics" CASCADE;
+
+DROP TABLE IF EXISTS "package_licenses" CASCADE;
+
+DROP TABLE IF EXISTS "package_license_alternatives" CASCADE;
+
+DROP TABLE IF EXISTS "package" CASCADE;
+
+DROP TABLE IF EXISTS "repository_prerequisites" CASCADE;
+
+DROP TABLE IF EXISTS "repository_complements" CASCADE;
+
+DROP TABLE IF EXISTS "repository" CASCADE;
+
+DROP TABLE IF EXISTS "tenant" CASCADE;
+
+DROP TABLE IF EXISTS "schema_version";
+
+CREATE TABLE "tenant" (
+  "id" TEXT NOT NULL PRIMARY KEY,
+  "creation_timestamp" BIGINT NOT NULL,
+  "archived" BOOLEAN NOT NULL);
+
+CREATE TABLE "repository" (
+  "tenant" TEXT NOT NULL,
+  "canonical_name" TEXT NOT NULL,
+  "location_url" TEXT NOT NULL,
+  "location_type" TEXT NOT NULL,
+  "display_name" TEXT NOT NULL,
+  "priority" INTEGER NOT NULL,
+  "interface_url" TEXT NULL,
+  "email" TEXT NULL,
+  "email_comment" TEXT NULL,
+  "summary" TEXT NULL,
+  "description" TEXT NULL,
+  "cache_location_url" TEXT NOT NULL,
+  "cache_location_type" TEXT NOT NULL,
+  "certificate_fingerprint" TEXT NULL,
+  "certificate_name" TEXT NULL,
+  "certificate_organization" TEXT NULL,
+  "certificate_email" TEXT NULL,
+  "certificate_pem" TEXT NULL,
+  "packages_timestamp" BIGINT NOT NULL,
+  "repositories_timestamp" BIGINT NOT NULL,
+  "internal" BOOLEAN NOT NULL,
+  "buildable" BOOLEAN NOT NULL,
+  PRIMARY KEY ("tenant",
+               "canonical_name"),
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED);
+
+CREATE TABLE "repository_complements" (
+  "repository_tenant" TEXT NOT NULL,
+  "repository_canonical_name" TEXT NOT NULL,
+  "index" BIGINT NOT NULL,
+  "complement_tenant" TEXT NOT NULL,
+  "complement_canonical_name" TEXT NOT NULL,
+  CONSTRAINT "repository_tenant_fk"
+    FOREIGN KEY ("repository_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "repository_fk"
+    FOREIGN KEY ("repository_tenant",
+                 "repository_canonical_name")
+    REFERENCES "repository" ("tenant",
+                             "canonical_name")
+    ON DELETE CASCADE,
+  CONSTRAINT "complement_tenant_fk"
+    FOREIGN KEY ("complement_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "complement_fk"
+    FOREIGN KEY ("complement_tenant",
+                 "complement_canonical_name")
+    REFERENCES "repository" ("tenant",
+                             "canonical_name")
+    INITIALLY DEFERRED);
+
+CREATE INDEX "repository_complements_repository_i"
+  ON "repository_complements" (
+    "repository_tenant",
+    "repository_canonical_name");
+
+CREATE INDEX "repository_complements_index_i"
+  ON "repository_complements" ("index");
+
+CREATE TABLE "repository_prerequisites" (
+  "repository_tenant" TEXT NOT NULL,
+  "repository_canonical_name" TEXT NOT NULL,
+  "index" BIGINT NOT NULL,
+  "prerequisite_tenant" TEXT NOT NULL,
+  "prerequisite_canonical_name" TEXT NOT NULL,
+  CONSTRAINT "repository_tenant_fk"
+    FOREIGN KEY ("repository_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "repository_fk"
+    FOREIGN KEY ("repository_tenant",
+                 "repository_canonical_name")
+    REFERENCES "repository" ("tenant",
+                             "canonical_name")
+    ON DELETE CASCADE,
+  CONSTRAINT "prerequisite_tenant_fk"
+    FOREIGN KEY ("prerequisite_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "prerequisite_fk"
+    FOREIGN KEY ("prerequisite_tenant",
+                 "prerequisite_canonical_name")
+    REFERENCES "repository" ("tenant",
+                             "canonical_name")
+    INITIALLY DEFERRED);
+
+CREATE INDEX "repository_prerequisites_repository_i"
+  ON "repository_prerequisites" (
+    "repository_tenant",
+    "repository_canonical_name");
+
+CREATE INDEX "repository_prerequisites_index_i"
+  ON "repository_prerequisites" ("index");
+
+CREATE TABLE "package" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "version_upstream" TEXT NOT NULL,
+  "version_release" TEXT NULL,
+  "upstream_version" TEXT NULL,
+  "project" CITEXT NOT NULL,
+  "priority" INTEGER NOT NULL,
+  "priority_comment" TEXT NOT NULL,
+  "summary" TEXT NOT NULL,
+  "description" TEXT NULL,
+  "description_type" TEXT NULL,
+  "changes" TEXT NOT NULL,
+  "url" TEXT NULL,
+  "url_comment" TEXT NULL,
+  "doc_url" TEXT NULL,
+  "doc_url_comment" TEXT NULL,
+  "src_url" TEXT NULL,
+  "src_url_comment" TEXT NULL,
+  "package_url" TEXT NULL,
+  "package_url_comment" TEXT NULL,
+  "email" TEXT NULL,
+  "email_comment" TEXT NULL,
+  "package_email" TEXT NULL,
+  "package_email_comment" TEXT NULL,
+  "build_email" TEXT NULL,
+  "build_email_comment" TEXT NULL,
+  "build_warning_email" TEXT NULL,
+  "build_warning_email_comment" TEXT NULL,
+  "build_error_email" TEXT NULL,
+  "build_error_email_comment" TEXT NULL,
+  "internal_repository_tenant" TEXT NULL,
+  "internal_repository_canonical_name" TEXT NULL,
+  "location" TEXT NULL,
+  "fragment" TEXT NULL,
+  "sha256sum" TEXT NULL,
+  "buildable" BOOLEAN NOT NULL,
+  "unbuildable_reason" TEXT NULL,
+  "search_index" tsvector NULL,
+  PRIMARY KEY ("tenant",
+               "name",
+               "version_epoch",
+               "version_canonical_upstream",
+               "version_canonical_release",
+               "version_revision"),
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "internal_repository_tenant_fk"
+    FOREIGN KEY ("internal_repository_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "internal_repository_fk"
+    FOREIGN KEY ("internal_repository_tenant",
+                 "internal_repository_canonical_name")
+    REFERENCES "repository" ("tenant",
+                             "canonical_name")
+    INITIALLY DEFERRED);
+
+CREATE INDEX "package_search_index_i"
+  ON "package" USING GIN ("search_index");
+
+CREATE TABLE "package_license_alternatives" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "comment" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_license_alternatives_object_id_i"
+  ON "package_license_alternatives" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_license_alternatives_index_i"
+  ON "package_license_alternatives" ("index");
+
+CREATE TABLE "package_licenses" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "alternative_index" BIGINT NOT NULL,
+  "index" BIGINT NOT NULL,
+  "license" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_licenses_object_id_i"
+  ON "package_licenses" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE TABLE "package_topics" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "topic" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_topics_object_id_i"
+  ON "package_topics" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_topics_index_i"
+  ON "package_topics" ("index");
+
+CREATE TABLE "package_keywords" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "keyword" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_keywords_object_id_i"
+  ON "package_keywords" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_keywords_index_i"
+  ON "package_keywords" ("index");
+
+CREATE TABLE "package_dependencies" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "conditional" BOOLEAN NOT NULL,
+  "buildtime" BOOLEAN NOT NULL,
+  "comment" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_dependencies_object_id_i"
+  ON "package_dependencies" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_dependencies_index_i"
+  ON "package_dependencies" ("index");
+
+CREATE TABLE "package_dependency_alternatives" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "dependency_index" BIGINT NOT NULL,
+  "index" BIGINT NOT NULL,
+  "dep_name" CITEXT NOT NULL,
+  "dep_min_version_epoch" INTEGER NULL,
+  "dep_min_version_canonical_upstream" TEXT NULL,
+  "dep_min_version_canonical_release" TEXT NULL,
+  "dep_min_version_revision" INTEGER NULL,
+  "dep_min_version_upstream" TEXT NULL,
+  "dep_min_version_release" TEXT NULL,
+  "dep_max_version_epoch" INTEGER NULL,
+  "dep_max_version_canonical_upstream" TEXT NULL,
+  "dep_max_version_canonical_release" TEXT NULL,
+  "dep_max_version_revision" INTEGER NULL,
+  "dep_max_version_upstream" TEXT NULL,
+  "dep_max_version_release" TEXT NULL,
+  "dep_min_open" BOOLEAN NULL,
+  "dep_max_open" BOOLEAN NULL,
+  "dep_package_tenant" TEXT NULL,
+  "dep_package_name" CITEXT NULL,
+  "dep_package_version_epoch" INTEGER NULL,
+  "dep_package_version_canonical_upstream" TEXT NULL,
+  "dep_package_version_canonical_release" TEXT NULL COLLATE "C",
+  "dep_package_version_revision" INTEGER NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE,
+  CONSTRAINT "dep_package_tenant_fk"
+    FOREIGN KEY ("dep_package_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "dep_package_fk"
+    FOREIGN KEY ("dep_package_tenant",
+                 "dep_package_name",
+                 "dep_package_version_epoch",
+                 "dep_package_version_canonical_upstream",
+                 "dep_package_version_canonical_release",
+                 "dep_package_version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    INITIALLY DEFERRED);
+
+CREATE INDEX "package_dependency_alternatives_object_id_i"
+  ON "package_dependency_alternatives" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE TABLE "package_requirements" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "conditional" BOOLEAN NOT NULL,
+  "buildtime" BOOLEAN NOT NULL,
+  "comment" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_requirements_object_id_i"
+  ON "package_requirements" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_requirements_index_i"
+  ON "package_requirements" ("index");
+
+CREATE TABLE "package_requirement_alternatives" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "requirement_index" BIGINT NOT NULL,
+  "index" BIGINT NOT NULL,
+  "id" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_requirement_alternatives_object_id_i"
+  ON "package_requirement_alternatives" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE TABLE "package_tests" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "test_name" CITEXT NOT NULL,
+  "test_min_version_epoch" INTEGER NULL,
+  "test_min_version_canonical_upstream" TEXT NULL,
+  "test_min_version_canonical_release" TEXT NULL,
+  "test_min_version_revision" INTEGER NULL,
+  "test_min_version_upstream" TEXT NULL,
+  "test_min_version_release" TEXT NULL,
+  "test_max_version_epoch" INTEGER NULL,
+  "test_max_version_canonical_upstream" TEXT NULL,
+  "test_max_version_canonical_release" TEXT NULL,
+  "test_max_version_revision" INTEGER NULL,
+  "test_max_version_upstream" TEXT NULL,
+  "test_max_version_release" TEXT NULL,
+  "test_min_open" BOOLEAN NULL,
+  "test_max_open" BOOLEAN NULL,
+  "test_package_tenant" TEXT NULL,
+  "test_package_name" CITEXT NULL,
+  "test_package_version_epoch" INTEGER NULL,
+  "test_package_version_canonical_upstream" TEXT NULL,
+  "test_package_version_canonical_release" TEXT NULL COLLATE "C",
+  "test_package_version_revision" INTEGER NULL,
+  "test_type" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE,
+  CONSTRAINT "test_package_tenant_fk"
+    FOREIGN KEY ("test_package_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "test_package_fk"
+    FOREIGN KEY ("test_package_tenant",
+                 "test_package_name",
+                 "test_package_version_epoch",
+                 "test_package_version_canonical_upstream",
+                 "test_package_version_canonical_release",
+                 "test_package_version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    INITIALLY DEFERRED);
+
+CREATE INDEX "package_tests_object_id_i"
+  ON "package_tests" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_tests_index_i"
+  ON "package_tests" ("index");
+
+CREATE TABLE "package_builds" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "expression" TEXT NOT NULL,
+  "comment" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_builds_object_id_i"
+  ON "package_builds" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_builds_index_i"
+  ON "package_builds" ("index");
+
+CREATE TABLE "package_build_constraints" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "exclusion" BOOLEAN NOT NULL,
+  "config" TEXT NOT NULL,
+  "target" TEXT NULL,
+  "comment" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE);
+
+CREATE INDEX "package_build_constraints_object_id_i"
+  ON "package_build_constraints" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_build_constraints_index_i"
+  ON "package_build_constraints" ("index");
+
+CREATE TABLE "package_other_repositories" (
+  "tenant" TEXT NOT NULL,
+  "name" CITEXT NOT NULL,
+  "version_epoch" INTEGER NOT NULL,
+  "version_canonical_upstream" TEXT NOT NULL,
+  "version_canonical_release" TEXT NOT NULL COLLATE "C",
+  "version_revision" INTEGER NOT NULL,
+  "index" BIGINT NOT NULL,
+  "repository_tenant" TEXT NOT NULL,
+  "repository_canonical_name" TEXT NOT NULL,
+  CONSTRAINT "tenant_fk"
+    FOREIGN KEY ("tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "object_id_fk"
+    FOREIGN KEY ("tenant",
+                 "name",
+                 "version_epoch",
+                 "version_canonical_upstream",
+                 "version_canonical_release",
+                 "version_revision")
+    REFERENCES "package" ("tenant",
+                          "name",
+                          "version_epoch",
+                          "version_canonical_upstream",
+                          "version_canonical_release",
+                          "version_revision")
+    ON DELETE CASCADE,
+  CONSTRAINT "repository_tenant_fk"
+    FOREIGN KEY ("repository_tenant")
+    REFERENCES "tenant" ("id")
+    INITIALLY DEFERRED,
+  CONSTRAINT "repository_fk"
+    FOREIGN KEY ("repository_tenant",
+                 "repository_canonical_name")
+    REFERENCES "repository" ("tenant",
+                             "canonical_name")
+    INITIALLY DEFERRED);
+
+CREATE INDEX "package_other_repositories_object_id_i"
+  ON "package_other_repositories" (
+    "tenant",
+    "name",
+    "version_epoch",
+    "version_canonical_upstream",
+    "version_canonical_release",
+    "version_revision");
+
+CREATE INDEX "package_other_repositories_index_i"
+  ON "package_other_repositories" ("index");
+
+CREATE TABLE "schema_version" (
+  "name" TEXT NOT NULL PRIMARY KEY,
+  "version" BIGINT NOT NULL,
+  "migration" BOOLEAN NOT NULL);
+
+INSERT INTO "schema_version" (
+  "name", "version", "migration")
+  VALUES ('package', 19, FALSE);
+