|
Reference Documentation
Navigation Guide
Using Sample Code
Getting Started
Product Philosophy
Data Persistence
OODBMS
Db4o Position
Why Choose Db4o
Basic Concepts
ACID Model
Atomicity
Consistency
Isolation
Durability
ACID Properties For Db4o
Isolation Level For Db4o
Concurrency Control And Locking
Pessimistic Locking
Optimistic Locking
Overly Optimistic Locking
Concurrency Control In Db4o
Types Of Locks
Locks In Db4o
Object Identity
Unique identity concept
Identity Vs Equals
Binding objects
Weak References
Transaction
Database Models
Object Database Model
Data Abstraction
Encapsulation
Inheritance
Relational Database Model
Object And Relational Model Comparison
Basic Terms
RDBMS And OODBMS Application
Object-Relational How To
Identity And Primary Keys
Foreign Keys
Referential Integrity
Triggers
Unique Constraints
Indexes
Concurrency Control
Native Query Concepts
Problems Of String Based Query Languages
Native Query Characteristics
Native Query Implementation
Native Query Optimization
Code Inside
Sorting Results
Object Lifecycle
Object Container
Simple Persistence
Class Name Format In .NET
Querying
Query By Example
QBE Limitations
Pilot1
Pilot1Derived
Pilot2
Pilot2Derived
Native Queries
Native Query Syntax
Java Syntax
.NET Syntax
SODA Query
Building SODA Queries
SODA Query Graph
SODA Query API
SODA Query Engine
LINQ
Simple Example
Type Safety
Optimization
Query Modes
Immediate Queries
Lazy Queries
Snapshot Queries
SODA Evaluations
Evaluation API
Using Evaluations
Drawbacks
Sorting Query Results
SODA Sorting
Native Query Sorting
Evaluation Results Sorting
Custom Query Comparator
Transparent Persistence
Transparent Persistence Implementation
TP Enhanced Example
TP Enhancement On Java
SensorPanel
Detailed Example
Collection Example
Working With Structured Objects
Retrieving Structured Objects
Updating Structured Objects
Deleting Structured Objects
Activation
Global Activation Settings
Object-Specific Activation
Transparent Activation Framework
TA Implementation
TA Enhanced Example
TA Enhancement At Loading Time
TA Enhancement At Build Time
TA Enhancement With Db4oTool
SensorPanel
SensorPanelTA
Detailed Example
Collection Example
Object Types In TA
TA Diagnostics
Update Depth
Collections Update Depth
Insert And Remove
Updating List Objects
Delete Behavior
Deleting Collection Members
Deleting Collections
Example Classes
Filling The Database
Object Construction
Creating objects
Configuration
Troubleshooting
Examples
Implementation Strategies
Maintenance
Defragment
How To Use Defragmentation
Defragmentation Configuration
Tracking Defragmentation Errors
Defragmentation Examples
Updating Db4o File Format
System Info
Backup
Type Handling
Collections
Built-in db4o collections
Fast collections
Collections Or Arrays
Blobs
Db4o Blob Implementation
Static Fields And Enums
Static fields API
Usage of static fields
Java enumerations
Delegates And Events
Final Fields
Final Fields Specifics
Possible Solutions
TypeHandlers
Custom Typehandler Example
Pluggable Typehandler Benefits
Using Annotations
Enhancement Tools
Enhancement For Java
Complex Example
Model Classes
Load Time Enhancement
Build Time Enhancement
Enhancement For .NET
Build Time Enhancement
TA and NQ Example Code
TP Example Code
Example Enhancement
SensorPanel
Db4oTool
Db4oTool Usage
Including Db4oTool In The Build
Using Attributes
Unique Constraints
How To Use Unique Constraints
Unique Constraints Example
Object Callbacks
Callbacks
Event Registry API
Possible Usecases
Cascaded Behavior
Referential Integrity
Query Statistics
Autoincrement
Benefits
Commit-Time Callbacks
How To Use Commit-Time Callbacks
Committing Event Example
Committed Event Example
Car
Translators
Java Example Class
.NET Example Class
The Translator API
ObjectConstructor
.NET Translator Implementation
Java Translator Implementation
Built-In Translators
TNull Translator
Collection Translators
TSerializable Translator
TTransient Translator
TCultureInfo Translator
TType Translator
TClass Translator
Db4o Reflection API
GenericReflector
Using db4o reflection API
Creating your own reflector
IO Adapter
Pluggable IO Concept
MemoryIoAdapter
CachedIoAdapter
Using CachedIoAdapter
CachedIoAdapter Example
Db4o meta-information
Accessing db4o meta-information
StoredClass and StoredField interfaces
LINQ Collection
Native Query Collection
Simple Selection
Using Selection Criterias
Selecting Ranges
Sorting
Result Representation
Calculation Examples
Combined Result Sets
Parameterized NQ
Store Pilots
Store Persons
Store Cars
Persistent Classes
Data Binding
Refactoring and Schema Evolution
Automatic refactoring
Refactoring API
Field type change
Refactoring Class Hierarchy
Removing Class From A Hierarchy
Inserting Class Into A Hierarchy
A
B
C
Aliases
TypeAlias
WildcardAlias
Cross-Platform Aliasing
Cross-Platform Aliasing From .NET To Java
Encryption
Built-In Simple Encryption
Custom Encryption Adapters
Class Mapping
Pilot
PilotReplacement
IDs and UUIDs
Internal IDs
Unique Universal IDs
Freespace Management System
Two Freespace Systems
How To Use FreeSpacemanager
Defragmentation Role
Reporting
Reporting With JasperReports
Report Structure
Data Source
Data Preparation
Report Design
Report Generation
ObjectDataSource
Reporting With BIRT
Data Preparation
Report Design
Scripted Data Source
Application-Report Integration
.NET Reporting
Persistent Class
Adding A Report
Db4o Integration
Report Integration
Db4o Manager
Exceptions
Exception Types
How To Work With Db4o Exceptions
Platform Specific Issues
db4o on Java Platforms
Security Requirements On Java Platform
db4o on .NET Platforms
Security Requirements On .NET Platform
Deployment Instructions
Db4o On Mono
Cross-Platform Applications
Configuration
Limitations Of Db4o Cross-Platform Usage
Symbian OS
Servlets
ASP.NET
Xml Import-Export In .NET
Xml Import-Export In Java
Classloader issues
Classloader basics
Configuration
Special Cases
Database For OSGi
Db4o-Osgi Usage
Eclipse Plug-In With Db4o Service
Creating A Plugin
Code Overview
Connecting To Db4o
Testing MemoPlugin
Isolated Storage
Isolated Storage IO Adapter
Isolated Storage Example
Benefits And Limitations
Db4oIsolatedStorageFile
IsolatedStorageFileAdapter
Android
General Info
Application Structure
Opening A Database
Storing Data
Retrieving Data
Changing Data
Deleting Data
Backup
Closing A Database
Schema Evolution
Car
Pilot
Tuning
Main Operations Performance
Insert Performance
Hardware Resources
Local And Remote Modes
Commit Frequency
Object Structure
Indexes
Inherited Objects
Configuration Options
IO Benchmark Tools
First Steps
Using Your Application To Generate The IO Pattern
Simulating Slow IO On A Fast Machine
IO Log File Statistics
Configuration
General Configuration
ClientServer Configuration
ObjectClass Configuration
ObjectField Configuration
Selective Persistence
Transient Fields In Java
Transient Fields In .NET
Transient Classes
Test1
Test2
Storing Transient Fields
Indexing
Performance Hints
Enable Field Indexes
Discarding Free Space
Calling constructors
Defragment
Turning Off Weak References
No Shutdown Thread
No callbacks
No schema changes
No lock file thread
No test instances
Increasing The Maximum Database File Size
FlushFileBuffers
B-Tree tuning
Inheritance hierarchies
Persistent and transient fields
Activation strategies
Automatic Shutdown
Reserving Storage Space
Unicode
Prefetching IDs For New Objects
Prefetching Objects For Query Results
No Class Index
No Field Evaluation
RandomAccessFileAdapter
Commit Strategies
Optimizing Native Queries
Debugging db4o
Debug Messaging System
Customizing The Debug Message Output
ExceptionsOnNotStorable
Using DTrace
Reading Db4o File
Diagnostics
ClassHasNoFields
LoadedFromClassIndex
NativeQueryNotOptimized
UpdateDepthGreaterOne
Diagnostic Messages Filter
DescendIntoTranslator
Native Query Optimization
Optimization at Query Execution Time
NQ Optimization At Load Time
Pilot
NQ Optimization At Build Time
NQ Optimization On CF2.0
Build-time Optimization For .NET
Monitoring Optimization
Utility Methods
PeekPersisted
IsActive
IsStored
Descend
Usage Pitfalls
Equality Comparison
QBE
Using Equals
Reference Cache In Client-Server Mode
Storing BigDecimal
Storing MarshalByRef Objects
Storing Timestamp And Date Values
Transparent Activation
Migrating Between Databases
Transparent Persistence
Object Clone
Rollback Strategies
Rollback And Cache
Automatic Deactivation
Car
Id
Pilot
Car
Accessing Persistent Classes From Different .NET Applications
Activation Depth
Classloader And Generic Classes
Client-Server Timeouts
Dangerous Practices
Update Depth
Working With Large Amounts Of Data
Client-Server
Embedded
Networked
Network Server
Out-of-band Signalling
Simple db4o Server
Native Queries In Client-Server Mode
Server Without Persistent Classes Deployed
Saving Objects
QBE
SODA
Native Queries
Evaluations
Multidimensional Arrays
Switching Database Files in CS Mode
Semaphores
Locking Objects
Ensuring Singletons
Limiting the Number of Users
Controlling Login Information
Pluggable Sockets
Using SSL For Client-Server Communication
Remote Code Execution
Remote Execution Through Evaluation API
Using Messaging API For Remote Code Execution
Concurrency Control
Optimistic Locking
Pessimistic Locking
Messaging
Batch Mode
Controlling Memory Consumption
Batch Messaging Example
db4o Replication System (dRS)
Getting Started
Db4o Databases Replication
Initial Setup
Simple Example
Bi-Directional Replication
Selective Replication
Replication With RDBMS
Configuration
Running DRS
Replication Examples
Simple Example
Collections
Array
List
Set
Map
Hibernate Replication Internals
Advanced Replication Strategies
Events
Conflict Resolution
Deleted Objects Replication
Deployment Instructions
License
Db4o Testing Framework
Db4ounit Methods
Creating A Sample Test
Running The Tests
Object Manager For db4o
Installation
Object Manager Specifics
Object Manager Tour
Working With Source Code
Using The Sources From Db4o Distribution
Using The Repository
Db4o Directory Structure
Configuring Java System Libraries
Building Java Version
Building .NET Version
Testing Db4o
Object Manager Sources
Patch Submission
Project Dependencies
Coding Style
License
Contacts