GemStone/S 64 Bit Programmer's Guide

1.1 GemStone Overview

• Multi-User

• Programmable

• Scalable

• Object Database

• Partition Between Client and Server

• Connect to Outside Data Sources

1.2 GemStone Services

• Transactions and Concurrency Control

• Login Security and Account Management

• Services To Manage the GemStone Repository

1.3 GemStone Smalltalk

• No User Interface

• GemStone Sessions

  • System Management Classes

• Monitoring your application

  • File In and File Out

• Interapplication Communications

1.4 Process Architecture

• Gem Process

• Stone Process

• NetLDI

• Shared Page Cache

• Extents and Repositories

• Transaction Log

2.1 Subclass Creation

• Implementation Formats

• Class Variables and Other Types of Variables

  • Dynamic Instance Variables

• Additional Class Creation Protocol

2.2 Creating Classes With Invariant Instances

• Per-Object Invariance

• Invariance for All Instances of a Class

2.3 Creating Classes with Special Cases of Persistence

• Non-Persistent Classes

• DbTransient

3.1 Sharing Objects

3.2 UserProfile and Session-Based Symbol Lists

• What’s In Your Symbol List?

• Examining Your Symbol List

• Inserting and Removing Dictionaries from Your Symbol List

• Updating Symbol Lists

• Finding Out Which Dictionary Names an Object

3.3 Using Your Symbol Dictionaries

• Publishers, Subscribers and the Published Dictionary

4.1 Introduction to Collections

• Protocol Common to All Collections

  • Creating Instances

  • Adding Elements

  • Removing Elements

  • Enumerating

4.2 Collection Subclasses

• Dictionaries

  • Dictionary

  • KeyValueDictionary

  • KeySoftValueDictionary

• SequenceableCollection

  • Adding and Removing Objects for SequenceableCollection

  • Comparing SequenceableCollection

  • Copying SequenceableCollection

  • Enumeration and Searching Protocol

• Array

  • Literal Array and Array Constructors

• SortedCollection

• UnorderedCollection

  • Bag and Set

  • IdentityBag

  • IdentitySet

4.3 Stream Classes

• PositionableStream and Position

4.4 Sorting

• Default Sort

  • Sorting Large Collections

  •  

5.1 Characters and Unicode

• Unicode and the Unicode Database

• Character Data Tables

  • Installing Character Data Tables

5.2 CharacterCollection and String classes

• CharacterCollection and String classes

  • Strings

  • Unicode Strings

  • Symbol

  • ByteArray

  • Utf8

• String equality, ordering, and interoperation

• String protocol

  • Creating Strings

  • Concatenating Strings

  • Converting between String classes and encodings

  • String Transformations

  • Equality and Identity

  • Searching and Pattern matching

5.3 String Sorting and Collation

• Traditional String Legacy Collation

• Unicode String Collation using ICU libraries

  • IcuLocale

  • IcuCollator

  • Customizing Sort

  • IcuSortedCollection

• Unicode Comparison Mode

5.4 Encrypting Strings

6.1 Integers

• SmallInteger

• LargeInteger

• Printing Integers

6.2 Binary Floating Point

• SmallDouble

• Float

• Literal Floats

• Printing Binary Floating Points

6.3 Other Rational Numbers

• Fractions

  • SmallFraction

  • Fraction

• FixedPoint

• ScaledDecimal

• DecimalFloat

• Summary of literal syntax

• Custom numeric literals

6.4 Internationalizing Decimal Points using Locale

6.5 Random Number Generator

7.1 Overview

• GemStone Indexes

  • Managing Indexes

• Indexing trade-offs

• Special Syntax for Indexing

7.2 Defining and Executing Queries

• Query Predicate Syntax

  • Predicate Terms

  • Combining Predicates using Boolean Logic

  • Combining Range Predicates

• Selection Block Queries

  • Selection Blocks

  • Executing Selection Block Queries

  • Return values

• Queries using GsQuery

  • Creating and Executing a GsQuery

  • Query Variables

  • GsQuery’s Collection protocol

  • Return values

• Query results as Streams

  • Limitations on streamable queries

7.3 Creating Indexes

• Equality and Identity Indexes

• Specialized subtypes of Indexes

  • Unicode Indexes

  • Reduced-conflict Equality Indexes

  • Implicit Indexes

• Creating indexes using GsIndexSpec

  • GsIndexOptions

• Creating indexes using UnorderedCollection protocol

• Reduced-Conflict Indexes

• Optional pathTerms

• While Indexes are Being Created

  • Queries during index creation

  • Auto-commit

7.4 Special Kinds of Queries and Indexes

• Unicode String Indexes and Queries

  • Creating Unicode Indexes

  • GsIndexSpec

  • UnorderedCollection protocol

  • Example

• Enumerated path terms in indexes and queries

  • Restrictions on predicates with enumerated pathTerms

• Indexes and Queries with collections on the path

  • Set-valued query results

  • Restrictions on predicates in set-valued queries

• Redefined Comparison Messages

7.5 Managing Indexes

• Indexes on temporary collections

• Inquiring About Indexes

• Removing Indexes

  • To remove indexes based on a GsIndexSpec

  • To remove indexes using IndexManager

  • To remove indexes using UnorderedCollection protocol

  • Rebuilding Indexes

• Indexing and Performance

  • Formulating queries and performance

• Indexing Errors

• Auditing Indexes

7.6 Query Formulas and Optimization

• Query Formulas

• Invariance and Formula reuse

• Disabling auto-optimize

• Query Formula Optimizations

  • Remove "not" using boolean logic

  • Convert predicates with equal operands into boolean constants

  • Convert constant-path reversed to path-constant

  • Eliminate redundant predicates

  • Combine path-constants into range predicate

  • Combine path-constants to enumerated predicate

  • Simplify (true) and (false) predicates

  • Reorder predicates

8.1 GemStone’s Conflict Management

• Views and Transactions

• Transaction State and Transaction Modes

• Reading and Writing in Transactions

• Reading and Writing Outside of Transactions

• When Should You Commit a Transaction?

• Nested In-memory Transactions

8.2 How GemStone Detects and Manages Conflict

• Concurrency Management

• Committing Transactions

• Handling Commit Failure in a Transaction

• Indexes and Concurrency Control

• Aborting Transactions

  • Updating the View Without Committing or Aborting

  • Being Signaled To Abort

  • Being Signaled to continueTransaction

• Handlers for abort or continueTransaction notifications

8.3 Controlling Concurrent Access with Locks

• Lock Types

  • Read Locks

  • Write Locks

• Acquiring Locks

  • Lock Denial

  • Dead Locks

  • Dirty Locks

  • Locking Collections of Objects Efficiently

  • Upgrading Locks

• Locking and Indexed Collections

• Removing or Releasing Locks

  • Releasing Locks Upon Aborting or Committing

• Inquiring About Locks

• Application Write Locks

8.4 Classes That Reduce the Chance of Conflict

• RcCounter

• RcIdentityBag

• RcQueue

• RcKeyValueDictionary

9.1 How GemStone Security Works

• Login Authorization

  • The UserProfile

• System Privileges

• Object-level Security

  • GsObjectSecurityPolicy

9.2 Assigning Objects to Security Policies

• Default Security Policy and Current Security Policy

• Objects and Security Policies

• Configuring Authorization for an Object Security Policy

  • How GemStone Responds to Unauthorized Access

  • Owner, Group, and World Authorization

• Predefined GsObjectSecurityPolicies

  • Changing the Security Policy for an Object

  • Revoking Your Own Authorization: a Side Effect

  • Finding Out Which Objects Are Protected by a Security Policy

9.3 Application Example

9.4 Development Example

9.5 Planning Security Policies for User Access

• Protecting the Application Classes

• CodeModification privilege

• Planning Authorization for Data Objects

• Planning Groups

• Planning Security Policies

• Developing the Application

  • Setting Up Security Policies for Joint Development

  • Making the Application Accessible for Testing

  • Moving the Application into a Production Environment

• Security Policy Assignment for User-created Objects

9.6 Privileged Protocol for Class GsObjectSecurityPolicy

10.1 Versions of Classes

• Defining a New Version

• New Versions and Subclasses

• New Versions and References in Methods

• Class Variable and Class Instance Variables

10.2 ClassHistory

• Defining a Class as a new version of an existing Class

• Accessing a Class History

• Assigning a Class History

10.3 Migrating Objects

• Migration Destinations

• Migrating Instances

  • Finding Instances and References

  • Using the Migration Destination

  • Bypassing the Migration Destination

  • Migration Errors

• Instance Variable Mappings

  • Default Instance Variable Mappings

  • Customizing Instance Variable Mappings

11.1 Accessing Files

• Specifying Files

• Creating a File

• Opening a File

• Closing a File or Files

• Writing to a File

• Reading from a File

  • Positioning

• Testing Files

• Renaming Files

• Removing Files

• Examining a Directory

• GsFile Errors

11.2 Executing Operating System Commands

• Simple Commands

• More complex interactions

11.3 File In and File Out

• Fileout

• Filein

11.4 PassiveObject

11.5 Creating and Using Sockets

• GsSocket

  • Establishing the connection

  • Communication on the socket

• GsSecureSocket

  • Set up certificates and private keys

  • Generating certificates

  • Enable or disable certificate validation

  • Setup CA certificates

  • Setup certificate, private key, and passphrase

  • Setup the Cipher list

  • Establishing the connection

  • Communication on the socket

  • Closing the socket

• Error handling

  • GsSocket

  • GsSecureSocket

12.1 Communicating Between Sessions

12.2 Object Change Notification

• Setting Up a Notify Set

  • Adding an Object to a Notify Set

  • Adding a Collection to a Notify Set

  • Listing Your Notify Set

  • Removing Objects From Your Notify Set

• Notification of New Objects

  • Receiving Object Change Notification

  • Reading the Set of Signaled Objects

• Polling for Changes to Objects

• Troubleshooting

  • Frequently Changing Objects

  • Special Classes

• Methods for Object Notification

12.3 Gem-to-Gem Signaling

• Sending a Signal

  • Receiving a Signal

12.4 Other Signal-Related Issues

• Inactive Gem

• Dealing With Signal Overflow

  • Sending Large Amounts of Data

• Maintaining Signals and Notification When Users Log Out

13.1 The Exception Class Hierarchy

13.2 Signaling Exceptions

13.3 Handling Exceptions

• Dynamic (Stack-Based) Handlers

• Selecting a Handler

• Flow of Control

• Default Handlers

• Default Actions

13.4 The Legacy Exception Handling Framework

• Dynamic (Stack-Based) Exception Handler

  • Installing a Dynamic (Stack-Based) Exception Handler

• Default (Static) Exception Handlers

  • Installing a Default (Static) Exception Handler

  • GemStone Event Exceptions

• Flow of Control

  • Signaling Other Exception Handlers

  • Removing Exception Handlers

  • Recursive Errors

• Raising Exceptions

• ANSI Integration

14.1 Clustering Objects for Faster Retrieval

• Will Clustering Solve the Problem?

• Cluster Buckets

  • Using Existing Cluster Buckets

  • Creating New Cluster Buckets

  • Cluster Buckets and Concurrency

  • Cluster Buckets and Indexing

• Clustering Objects

  • The Basic Clustering Message

  • Depth-First Clustering

  • Assigning Cluster Buckets

  • Clustering and Memory Use

  • Using Several Cluster Buckets

  • Clustering Class Objects

• Maintaining Clusters

  • Determining an Object’s Location

  • Why Do Objects Move?

14.2 Profiling Smalltalk Execution

• Classes ProfMonitor and ProfMonitorTree

  • Sample intervals

  • Reporting limits

  • Temporary results file

  • Real vs. CPU time

• Profiling Code

• The Profile Report

• Profiling Beyond Performance

  • Object Creation Tracking

  • Memory Use Profiling

14.3 Modifying Cache Sizes for Better Performance

• GemStone Caches

  • Temporary Object Space

  • Gem Private Page Cache

  • Stone Private Page Cache

  • Shared Page Cache

• Getting Rid of Non-Persistent Objects

14.4 Managing VM Memory

• Large Working Set

• Class Hierarchy

• UserAction Considerations

• Exported Set

• Debugging out of memory errors

• Signal on low memory condition

• Methods for Computing Temporary Object Space

• Statistics for monitoring memory use

14.5 NotTranloggedGlobals

14.6 Other Optimization Hints

15.1 Creating and Removing Methods

• Defining Simple Accessing and Updating Methods

• Compiling Methods

• Removing Methods

15.2 Information about Class and Methods

• Information about the Class

• Information about Instance, Class, and Shared Pool variables

• Information about Method Selectors

• Accessing and Managing Method Categories

• Specific Methods

15.3 Transient Methods

15.4 ClassOrganizer

15.5 Handling Deprecated Methods

• Deprecated handling

• Deprecation log

• Listing deprecated methods

• Determining senders of deprecated methods

16.1 Hidden Sets

• Methods to work with Hidden Sets

16.2 SessionTemps and access to Session State

• SessionState

16.3 Shared Counters

• AppStat Shared Counters

• Persistent Shared Counters

17.1 Overview of the Foreign Function Interface

17.2 FFI Core Classes

• CLibrary

• CCallout

• C type symbols

• Limitations with native code disabled

• CCallin

• CByteArray

• CFunction

• CPointer

17.3 FFI Wrapper Utilities

• Creating a Smalltalk class

18.1 Specifying NRS with GsNetworkResourceString

• Gem NRS methods

• Stone NRS methods

• GsNetworkResourceString direct protocol

18.2 Using External Sessions

• Setup the External Session

  • Creating the External Session

• Log in the External Session

• Executing Code

• Managing Remote Sessions

  • Managing transaction state

  • Logging

  • Breaking remote execution

• Important caution on Export Set of remote session

• Exceptions

19.1 Why SUnit?

19.2 Testing and Tests

19.3 SUnit by Example

• Examining the Value of a Tested Expression

• Finding Out If an Exception Was Raised

19.4 The SUnit Framework

19.5 Understanding the SUnit Implementation

• Running a Single Test

• Running a TestSuite

19.6 For More Information

A.1 GemStone and ANSI Smalltalk

A.2 GemStone Smalltalk

• How to Create a New Class

• Case-Sensitivity

• Statements

• Comments

• Expressions

  • Kinds of Expressions

  • Literals

  • Numeric Literals

  • Character Literals

  • String Literals

  • Symbol Literals

  • Array Literals

• Variables and Variable Names

  • Declaring Temporary Variables

  • Pseudovariables

• Assignment

• Message Expressions

  • Messages

• Reserved and Optimized Selectors

  • Messages as Expressions

• Combining Message Expressions

  • Summary of Precedence Rules

• Cascaded Messages

• Array Constructors

• Path Expressions

• Returning Values

A.3 Blocks

• Blocks with Arguments

• Blocks and Conditional Execution

  • Conditional Selection

  • Two-Way Conditional Selection

  • Conditional Repetition

• Formatting Code

A.4 GemStone Smalltalk BNF