|
development |
Many multi-tier applications nowadays use the database as a pure data repository. On the
question "Who ensures the data consistency between these two tables?", one usually gets
the answer: "This is being ensured by the application server!". Tables are being addressed
via object-relational mappings and the entire program logic is implemented outside of the
database.
In our opinion, this approach bears at least two risks:
- On the one hand, no application can enforce data consistency and integrity
like a database, that was designed specially for this purpose, can. It is
sufficient to insert or update data directly via a loader or a database development
tool to render the best application server useless.
- On the other hand, a database offers optimized data access techniques
and patterns which take into consideration the storage of data, their contents, as
well as connections between data -- information usually not available outside the
database. An - optimized - join runs nowhere faster than in a database.
A database can do far more than administrate extents. Starting with data consistency, going
through performance optimization, and ending with embedding procedural objects, a database
offers powerful instruments. This is why our approach is to use the features a database
offers - including integrated development environments - to the maximum of their capabilities.
This means for example:
- Implement those parts of the program logic inside the database,
which run more efficiently and safely there.
- Use normalized data structures. De-normalized tables should be used
only on purpose and targeted, for example on the higher levels of data warehouses for
performance enhancement.
- Constraints are powerful instruments for enforcing data integrity and
consistency, which a database validates very efficiently. Therefore, constraints -
including relations (foreign keys) - should be used, whenever possible.
- All object types available in a database - indexes, views,
procedures, triggers etc. - should be used.
- Performance tuning should be done actively. No - complex - statement
should go into production before its execution plan was analyzed and found optimal;
statistics should be gathered for all tables, indexes, and relevant columns, etc.
- Parallelism should be used whenever the database offers it and
resources are available - for example in Selects, Create Index statements, etc.
- . . .
|
|
|