FileDictionary ( http://guzdial.cc.gatech.edu/st/filedict.8May1231pm.cs ) is a super-simple database for Squeak. Basically, you can use it like a Dictionary, except that you (a) must create it with a fileNamed: method and (b) you must explicitly open and close the FileDictionary. The parts of the Dictionary protocol that FileDictionary understands:

• at:
• at:put:
• keysDo:
• do:

FileDictionary actually uses two files. The data (values) will be stored in the filename provided when creating the FileDictionary. The index into the database will be stored in a file with the same name, adding on the suffix ".toc" (for Table Of Contents). The TOC file is what gets read at open and written at close.

There are examples in the class method basicExamples. Here's an example of writing things to the FileDictionary:

| fd newDict |
fd := FileDictionary fileNamed: 'samplefd'.
fd open.
fd at: 'fred' put: 'ethel'.
fd at: 'tim' put: #(0 1 2 3).
newDict _ Dictionary new.
newDict at: 'mary' put: 'poppins'.
newDict at: 'fred' put: 'astaire'.
fd at: 'names' put: newDict.
fd close.

And here's how you might read things back in again:

| fd |
fd := FileDictionary fileNamed: 'samplefd'.
fd open.
Transcript show: (fd at: 'fred'); cr.
fd do: [:anAssoc | Transcript show: anAssoc printString ; cr].
fd close.

Implementation and Caveats

The implementation of FileDictionary is important in that it limits what values can be stored. FileDictionary is implemented on top of a subclass of DataStream. Data is written out onto the database file using DataStream. The index dictionary in FileDictionary tracks the position in the database file where the value object begins. New objects are always written at the end of the database file. DataStream is also used to read in and write out the index dictionary.

The caveats that this implementation introduces:

• Writes are fast, but the database always gets larger and larger. To compact it, simply write the database to a new one:

  | fd newfd |
  fd := FileDictionary fileNamed: 'samplefd'.
  newfd := FileDictionary fileNamed: 'newfd'.
  fd open. newfd open.
  fd keysDo: [:key | newfd at: key put: (fd at: key)].
  fd close. newfd close.
  

• The value for any key cannot have cycles, and should not refer to many other (especially large) objects. DataStream is not speedy. But writing out values of simple objects seems to work just fine.

I wouldn't use FileDictionary for any kind of persistent object implementation. ReferenceStream (or SmartRefStream) are much better for that kind of thing but I can't change the position on the underlying bytestream safely, which is why I subclassed DataStream as PositionableDataStream for FileDictionary.

Updates

• Thu, Mar 26, 1998- Updated to fix at:ifAbsent: and to provide keys
• Mon, Mar 23, 1998 at 12:36:49 PM - First release