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 Strings
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
Fraction
FixedPoint
ScaledDecimal
DecimalFloat
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
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
Collection path Indexes and Queries
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
Locking and Manual Transaction Mode
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
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.5 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
Writing Extended Characters 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
Handling strings with extended characters
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
Closing the socket
Error handling
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
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
Profiling Your Code
The Profile Report
14.3 Modifying Cache Sizes for Better Performance
GemStone Caches
Temporary Object Space
Gem Private Page Cache
Stone Private 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 ClassOrganizer
15.4 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 ExternalSessions
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