==========================
 Announcing PyTables 1.1.1
==========================

This is a maintenance release of PyTables. In it, several optimizations
and bug fixes have been made. As some of the fixed bugs were quite
important, it's strongly recommended for users to upgrade.

Go to the PyTables web site for downloading the beast:
http://pytables.sourceforge.net/

or keep reading for more info about the improvements and bugs fixed.


Changes more in depth
=====================

Improvements:

- Optimized the opening of files with a large number of objects. Now,
  files with table objects open a 50% faster, and files with arrays open
  more than twice as fast (up to 2000 objects/s on a Pentium
  4@2GHz). Hence, a file with a combination of both kinds of objects
  opens between a 50% and 100% faster than in 1.1.

- Optimized the creation of ``NestedRecArray`` objects using
  ``NumArray`` objects as columns, so that filling a table with the
  ``Table.append()`` method achieves a performance similar to PyTables
  pre-1.1 releases.

Bug fixes:

- ``Table.readCoordinates()`` now converts the coords parameter into ``Int64``
  indices automatically.

- Fixed a bug that prevented appending to tables (though
  ``Table.append()``) using a list of ``NumArray`` objects.

- Solved a small bug for creating indexes for first time in tables and
  retain the filter properties for posterior use.

- ``Int32`` attributes are handled correctly in 64-bit platforms now.

- Correction for accepting lists of numarrays as input for
  ``NestedRecArrays``.

- Fixed problem creating rank 1 multi-dimensional string columns in ``Table``
  objects. Closes SF bug #1269023.

- Avoid errors when unpickling objects stored in attributes.  See the
  section ``AttributeSet`` in the reference chapter of the User's
  Manual for more information. Closes SF bug #1254636.

- Assignment for ``*Array`` slices has been improved in order to solve
  some issues with shapes. Closes SF bug #1288792.

- The indexation properties were lost in case the table was closed
  before an index was created. Now, these properties are saved even in
  this case.

Known bugs:

- Classes inheriting from ``IsDescription`` subclasses do not inherit
  columns defined in the super-class. See SF bug #1207732 for more info.

- Time datatypes are non-portable between big-endian and little-endian
  architectures. This is ultimately a consequence of a HDF5
  limitation. See SF bug #1234709 for more info.

Backward-incompatible changes:

- None.

Important note for MacOSX users
===============================

UCL compressor seems to work badly on MacOSX platforms. Until the
problem is isolated and eventually solved, UCL support will not be
compiled by default on MacOSX platforms, even if the installer finds it
in the system. However, if you still want to get UCL support on MacOSX,
you can use the ``--force-ucl`` flag in ``setup.py``.


Important note for Python 2.4 and Windows users
===============================================

If you are willing to use PyTables with Python 2.4 in Windows
platforms, you will need to get the HDF5 library compiled for MSVC
7.1, aka .NET 2003.  It can be found at:
ftp://ftp.ncsa.uiuc.edu/HDF/HDF5/current/bin/windows/5-164-win-net.ZIP

Users of Python 2.3 on Windows will have to download the version of
HDF5 compiled with MSVC 6.0 available in:
ftp://ftp.ncsa.uiuc.edu/HDF/HDF5/current/bin/windows/5-164-win.ZIP


What it is
==========

**PyTables** is a package for managing hierarchical datasets and
designed to efficiently cope with extremely large amounts of data
(with support for full 64-bit file addressing).  It features an
object-oriented interface that, combined with C extensions for the
performance-critical parts of the code, makes it a very easy-to-use
tool for high performance data storage and retrieval.

Perhaps its more interesting feature is that it optimizes memory and
disk resources so that data take much less space (between a factor 3
to 5, and more if the data is compressible) than other solutions, like
for example, relational or object oriented databases.

Besides, PyTables I/O for table objects is buffered, implemented in C
and carefully tuned so that you can reach much better performance with
PyTables than with your own home-grown wrappings to the HDF5
library. PyTables sports indexing capabilities as well, allowing doing
selections in tables exceeding one billion of rows in just seconds.


Where can PyTables be applied?
==============================

PyTables is not designed to work as a relational database competitor,
but rather as a teammate.  If you want to work with large datasets of
multidimensional data (for example, for multidimensional analysis), or
just provide a categorized structure for some portions of your
cluttered RDBS, then give PyTables a try.  It works well for storing
data from data acquisition systems (DAS), simulation software, network
data monitoring systems (for example, traffic measurements of IP
packets on routers), very large XML files, or for creating a
centralized repository for system logs, to name only a few possible
uses.


What is a table?
================

A table is defined as a collection of records whose values are stored
in fixed-length fields.  All records have the same structure and all
values in each field have the same data type.  The terms
"fixed-length" and "strict data types" seem to be quite a strange
requirement for a language like Python that supports dynamic data
types, but they serve a useful function if the goal is to save very
large quantities of data (such as is generated by many scientific
applications, for example) in an efficient manner that reduces demand
on CPU time and I/O resources.


What is HDF5?
=============

For those people who know nothing about HDF5, it is a general purpose
library and file format for storing scientific data made at NCSA.
HDF5 can store two primary objects: datasets and groups.  A dataset is
essentially a multidimensional array of data elements, and a group is
a structure for organizing objects in an HDF5 file.  Using these two
basic constructs, one can create and store almost any kind of
scientific data structure, such as images, arrays of vectors, and
structured and unstructured grids.  You can also mix and match them in
HDF5 files according to your needs.


Platforms
=========

We are using Linux on top of Intel32 as the main development platform,
but PyTables should be easy to compile/install on other UNIX machines.
This package has also been successfully compiled and tested on a
FreeBSD 5.4 with Opteron64 processors, a UltraSparc platform with
Solaris 7 and Solaris 8, a SGI Origin3000 with Itanium processors
running IRIX 6.5 (using the gcc compiler), Microsoft Windows and
MacOSX (10.2 although 10.3 should work fine as well). In particular,
it has been thoroughly tested on 64-bit platforms, like Linux-64 on
top of an Intel Itanium, AMD Opteron (in 64-bit mode) or PowerPC G5
(in 64-bit mode) where all the tests pass successfully.

Regarding Windows platforms, PyTables has been tested with Windows
2000 and Windows XP (using the Microsoft Visual C compiler), but it
should also work with other flavors as well.


Web site
========

Go to the PyTables web site for more details:

http://pytables.sourceforge.net/

To know more about the company behind the PyTables development, see:

http://www.carabos.com/


Share your experience
=====================

Let us know of any bugs, suggestions, gripes, kudos, etc. you may
have.


----

  **Enjoy data!**

  -- The PyTables Team

.. Local Variables:
.. mode: text
.. coding: utf-8
.. fill-column: 72
.. End:
