•  Preface
  • Purpose
  • Audience
  • Organization
  •  Using this manual
    • References to ABL compiler and run-time features
    • References to ABL data types
  • Typographical conventions
  •  Examples of syntax descriptions
    • Long syntax descriptions split across lines
    • Complex syntax descriptions with both required and optional elements
  • Example procedures
  •  OpenEdge messages
    • Obtaining more information about OpenEdge messages
•  Data Management
  •  Database Access
    •  Database connections
      • Connection parameters
      • Secure database connections
      • The CONNECT statement
      • Auto-connect
      • Multi-database connection considerations
      • Run-time connection considerations
      •  Connection failures and disruptions
        • Using CONNECT with NO-ERROR
        • Using the CONNECTED function
      • OpenEdge database connection functions
      • Balancing conserving connections with minimizing overhead
    • Disconnecting databases
    • Logical database names
    •  Database aliases
      • Creating aliases in applications
      • Compiling procedures with aliases
      • Using shared record buffers with aliases
    • Data-handling statements
    • Adding and deleting records
    • Defining a set of records to fetch
    •  Fetching records
      • Order of fetched records
      • Sample record fetches
      •  ROWID and RECID data types
        • Comparing ROWID and RECID
        • Returning record ROWID values
        • Storing and retrieving ROWID and RECID values
        • Additional ABL support
        • Converting from RECID to ROWID
        • Writing DataServer-portable applications
      •  Results lists
        • Navigating a Results list
      •  FIND repositioning
        • Repositioning after FIND fetches
    •  Fetching field lists
      • Field list benefits
      •  Specifying field lists in ABL
        • Queries versus record selection blocks
        • Shared queries
      • Avoiding implied field list entries
      •  Updating and deleting with field lists
        • Updating and deleting with query field lists
      • Cursor repositioning and field lists
      • Field list handling in degenerate cases
    •  Joining tables
      •  Specifying joins in ABL
        • Specifying the type of join
        • Relating and selecting tables
        • Using joins instead of nested reads
      • Using inner joins
      • Using left outer joins
      • Implementing other outer joins
      • Mixing inner and left outer joins
    •  The CONTAINS operator
      • The CONTAINS operator and word indexes
      • Word indexes and word-break tables
      •  Creating and viewing word indexes
        • Word indexing very large fields
        • Word indexing double-byte and triple-byte code pages
      •  Using word-break tables
        • Specifying word delimiter attributes
        • Understanding the syntax of word-break tables
        • Examples of word-break tables
        • Compiling word-break tables
        • Associating compiled word-break tables with databases
        • Word-break tables for double-byte and UTF-8 databases
        • Rebuilding word indexes
        • Providing access to the compiled word-break table
      •  Writing queries using the CONTAINS operator
        • Syntax of the CONTAINS operator of the WHERE option
        • Examples of the CONTAINS operator
      •  Word indexing external documents
        • Indexing by line
        • Indexing by paragraph
      • Word indexing non-OpenEdge databases
    •  Sequences
      •  Choosing between sequences and control tables
        • Using sequences or control tables
        • Performance versus capabilities
        • Transaction independence
        • Storage limits
      •  Creating and maintaining sequences
        • Providing sequence security
        • Dumping and loading sequences
      •  Accessing and incrementing sequences
        • Using the CURRENT-VALUE function
        • Using the NEXT-VALUE function
        • Using the CURRENT-VALUE statement
        • Compiling procedures that reference sequences
        • Resetting a terminating sequence
        • Referencing sequences within a WHERE clause
    •  Database trigger considerations
      • Storing triggers in an operating system directory
      • Storing triggers in an r-code library
    • Using the RAW data type
    •  Multi-database programming techniques
      • Referencing tables and fields
      • Positioning database references in an application
      • Using the LIKE option
    •  Creating schema cache files
      • Building a schema cache file
      • Example schema cache file creation
      • Using a schema cache file
  •  Application Security
    • Types of application security
    •  Elements of an application authentication model
      • Authentication systems
      • Security domains
      • Domain registries
      • User credentials
      • Security tokens (client-principal objects)
      • User identity management mechanisms
      • Client context management mechanisms
      • Application authentication design options
    •  Elements for authenticating ABL user identity
      • Authentication systems supported in ABL
      • Specifying user IDs and passwords in ABL
      • Password encryption
      • Security tokens in ABL
    •  Authenticating and managing user identity in ABL
      • User identity applications
      • ABL for managing user identity
      •  Client-principal objects
        • Unsealed and sealed client-principals
        • Client-principal object attributes
        • Client-principal object methods
      •  Setting up and using domain registries
        • Identifying the trusted domain registry
        • Building and using a session domain registry
      •  Authenticating and setting user identity
        • User ID (-U) and Password (-P) database connection parameters
        • SET-DB-CLIENT function
        • SETUSERID function
        • SET-CLIENT( ) method on the SECURITY-POLICY system handle
        • SEAL( ) method on the client-principal object handle
        • Initializing a client-principal for user authentication and SSO
        • Managing the client-principal after establishing identity
        • Configuring login sessions
        • Starting and maintaining user login sessions
      •  Establishing database connection identity
        • Built-in client support for authenticating database connection identity
        • Setting connection identity with application-performed user authentication
      •  Establishing ABL session identity
        • Setting the ABL session identity
      •  Establishing and managing identity for multi-tier applications
        • Initializing a client-principal object for a multi-tier application
        • Managing user identities for a stateless application service
        • Managing user identities for a state-free application service
      • Establishing auditing identity
      • Creating and managing unique object identities
    •  Authorizing access to procedures and database resources
      • Authorizing users from within a given procedure
      •  Defining activities-based user authorization
        • Creating an application activity permissions table
        • Adding records to the permissions table
        • Including security checking in procedures
        • Protecting and maintaining the permissions table
      • Authorizing user access to tables and fields
    •  Using ABL callbacks in authentication systems
      • Advantages of using ABL authentication callbacks
      • Running ABL callbacks
      • Adding an ABL callback to an authentication system
      • Extending the built-in systems where OpenEdge performs user authentication
      • Extending SSO-only authentication systems
      • Using ABL to implement user authentication systems
      •  Creating an ABL authentication callback procedure
        • AuthenticateUser and AfterSetIdentity signatures
        • ABL authentication callback procedure example
    •  Using cryptography to secure data
      •  Creating and maintaining a cryptography policy
        • Setting a symmetric encryption algorithm
        • Setting an encryption key
      • Generating encryption keys
      •  Implementing symmetric cryptography in ABL
        • Using ABL encryption and decryption functions
        • Example code using the ENCRYPT and DECRYPT functions
      •  Using message digests in ABL
        • Securing a message digest
        • Generating message digests in ABL
        • Managing message digests
      •  Managing and transporting crypto data
        • Objectives for crypto data management
        • Requirements for crypto data management
        • Crypto data storage
        • Crypto data management and transport
        • Planning for changes in size for encrypted data
  •  Multi-tenant ABL
    •  Running applications in a multi-tenant database environment
      • Existing applications
      • Super-tenant applications
    •  Coding for super-tenant access
      • Setting effective tenancy
      •  Tenancy identification
        • Identifying database connection tenancy
        • Identifying database record tenancy
        • Identifying tenancy in temp-tables
        • Identifying the tenants defined in a database
      •  Super-tenant queries
        • TENANT-WHERE option of the record phrase
        • SKIP-GROUP-DUPLICATES option of TENANT-WHERE
        • Query examples without groups
        • Query examples with groups
      • Super-tenant data updates
      • Super-tenant sequence access
    •  Using multi-tenant-enabled sequences
      • Using multi-tenant sequences with shared and group-configured tables
      • Restrictions for using groups and sequences
    • Managing access to tables with groups
  •  ABL API for Multi-tenant and Table Partition Management
    •  Overview of the API
      •  API packages, classes, and interfaces
        • Interface naming conventions
        • Creating and accessing objects with the API
      • API entities and entity service methods
    • Instantiating a DataAdminService
    • Managing the service life cycle
    •  Managing transactions
      • Table updates that require two transactions
    •  Maintaining multi-tenant and table partition entities
      • Areas (creating and reading)
      • Authentication systems (creating, reading, updating and deleting)
      • Domains (creating, reading, updating and deleting)
      • Schema (reading, loading, and updating)
      • Sequences (creating, reading, updating and deleting)
      • Tables (reading and updating)
      • Table permissions (reading and updating)
      •  Tenants (creating, reading, updating and deleting)
        • Getting a tenant by an external ID
      • Tenant groups (creating, reading, updating and deleting)
      • Users (creating, reading, updating and deleting)
      • User permissions (reading)
      • Partitions (creating, reading, updating, deleting, enabling and allocating)
      •  Working with Partitions
        • Splitting a Partition
    •  Filtering and sorting
      • Filter expressions
      •  Filtering on a child collection using the RequestInfo class
        • IRequestInfo interface properties
        • IRequestInfo interface methods
    •  Exporting and importing
      • Exporting and importing objects as JSON files
      • Exporting tenants and tenant groups as ABL code
    • Exporting and Importing Partition Policies and Details
    •  Executing DataAdminService utilities
      • IDataAdminUtility interface
      • DeallocateUtility class
      •  PartitionMergeUtility class
        • Merge one partition into a target partition
        • Merge multiple partitions into a target partition
      •  PartitionSplitUtility class
        • Split from a composite partition
        • Split from an allocated partition detail
    •  Handling errors
      • Handling data errors with the DataAdminErrorHandler class
      •  Controlling data errors with the IDataAdminService interface
        • IDataAminService interface public properties for error handling
        • IDataAminService interface public methods for error handling
    • Configuring the sample multi-tenant database
  •  Auditing
    •  Setting up application security for auditing
      • Configuring the auditing identity
      •  Asserting the auditing identity
        • Using the database connection ID
        • Using the OpenEdge session ID
        • Application design considerations
      • Verifying that auditing is enabled
      • Configuring auditing privileges
    •  Recording application events
      • Planning application events
      • ABL for generating application events
      • Instructing OpenEdge to record an application event
      •  Managing audit event context
        • Generating client login session context
        • Generating application context
        • Generating audit event groups
      •  Application design considerations
        • Supporting OERA-conformant clients
        • Examining active audit policies
    •  Developing auditing tools
      •  Custom audit configuration tools
        • Accessing the audit policy tables
        • Accessing the Audit Policy Maintenance APIs
        • Audit configuration security
      •  Custom audit archiving tools
        • Accessing the audit data and supporting tables
        • Handling archiving requirements
        • Audit archiving security
•  Input/Output Processes
  •  Making HTTP(S) requests from ABL applications
    • Introduction
    • Configuration
    •  Basic request-response functionality
      • OpenEdge.Net.HTTP.IHttpRequest
      • OpenEdge.Net.HTTP.HttpClient
      • OpenEdge.Net.HTTP.IHttpResponse
      • OpenEdge.Net.URI
    • Implementing stateful clients with cookies
    • Security considerations
  •  Handling User Input
    •  The keyboard and the mouse
      • Key mapping
      • Key monitoring
      • Key translation functions
    • Key codes and key labels
    • Key functions
    • Changing the function of a key
    •  Using mouse buttons and events
      • Portable and physical buttons
      •  Specifying mouse events
        • Portable and three-button event priority
        • Low-level and high-level events
    • Telling the AVM how to continue processing
    •  Monitoring keystrokes during data entry
      • Editing blocks
      • User interface triggers
      • Using editing blocks and user interface triggers
  •  Alternate I/O Sources
    • Understanding input and output
    •  Changing the output destination
      • Output to printers
      •  Additional options for printing in Windows
        • Getting a list of printers
        • Changing the default printer
        • Providing access to the print dialog box
      • Output to files or devices
      • Output to the clipboard
      • Resetting output to the terminal
      • Sending output to multiple destinations
      • Stream I/O vs. screen I/O
      • A printing solution
    •  Changing the input source of a procedure
      • Input from files
      • Input from devices, directories, and the terminal
      • Receiving input from multiple sources
      • Reading input with control characters
    • Defining additional input/output streams
    •  Sharing streams among procedures
      • Defining a shared stream
      • Using stream object handles
    • Summary of opening and closing streams
    •  Processes as input and output streams (NT and UNIX only)
      • Portability issues
    • I/O redirection for batch jobs
    • Reading the contents of a directory
    • Performing code-page conversions
    •  Converting nonstandard input files
      •  Importing and exporting data
        • Using the EXPORT statement
        • Using the PUT statement
        • Using the IMPORT statement
  •  Colors and Fonts
    •  Making colors and fonts available to an application
      • OpenEdge default colors
      • OpenEdge default fonts
    • Assigning colors and fonts to a widget
    • Assigning colors and fonts to ActiveX Automation objects and ActiveX controls
    •  Color and font inheritance
      • Overriding default color inheritance
    •  Color in character interfaces
      • Widget states and color
      • Color specification
    •  Colors in windows in graphical interfaces
      •  Systems with the Palette Manager
        • Managing colors for multiple windows
        • Managing colors for bitmap images
      • Systems without the Palette Manager
    • Managing colors and fonts in graphical applications
    •  Allowing the user to change colors and fonts
      • Establishing dynamic colors
      • Color dialog box
      • Color dialog box example
      • Saving a modified color
      • Font dialog box
      • Font dialog box example
      • Saving a modified font
    •  Accessing the current color and font tables
      • COLOR-TABLE handle
      • FONT-TABLE handle
    •  Retrieving and changing color and font definitions
      •  Changing resource definitions
        • Portable color and font definitions
      •  Using GET-KEY-VALUE and PUT-KEY-VALUE
        • Writing portable color and font definitions
    •  Managing application environments
      • Understanding environment management
      • Using environment management statements
      •  Managing multiple environments
        • Helpful hints for environment management
    • Managing color display limitations
  •  Creating Reports
    •  Report basics
      • Down frames
      • Text widgets
      • Control blocks and output statements
      • Basic report demonstration
    • Designing an interface for viewing report data
    •  Converting widget values to report data
      • Printing reports and the STREAM-IO option
      • Formatting long text strings
    • Generating reports with control breaks and aggregates
    •  Generating reports from multiple tables
      • Reporting information from one table
      • Reporting information from two tables
      • Reporting information from multiple tables
    •  Redirecting output
      • OUTPUT TO and the default stream
      • Directing output to a file
      • Directing output to a printer
      • Directing output to multiple destinations
    •  Designing frames for reports
      • Using base fields with the @ option
      • Using the HEADER of a frame for running page heads
      • Using the HEADER of a frame for running page footers
      • Programming example
    •  Using the PUT statement
      • Using PUT for printer control
    •  Summary
      • Generating simple reports
      • Redirecting output
      • Generating reports of data represented by widgets
      • Customizing reports
•  External Program Interfaces
  •  Introduction to External Program Interfaces
    •  Using MEMPTR to reference external data
      • Comparing MEMPTR and RAW data types
      •  Initializing and uninitializing MEMPTR variables
        • Initializing MEMPTR variables using the SET-SIZE statement
        • Checking a MEMPTR variable for initialization
        • Freeing memory associated with a MEMPTR variable
      •  Reading and writing data
        • Memory-writing statements
        • Memory-reading functions
        • Copying between basic ABL data types and MEMPTR
        • Manipulating bit values
        • Copying between database records and MEMPTR
      • Retrieving and storing pointers
      • Setting byte order
    •  System clipboard
      • The system clipboard and ABL
      • Requirements for using the CLIPBOARD handle
    •  Named pipes
      • Named pipes and ABL
      • Requirements for using named pipes
    •  UNIX shared library and Windows DLL support
      • Shared libraries and ABL
      • Requirements for using shared libraries
    •  Windows Dynamic Data Exchange
      • DDE and ABL
      • Requirements for using DDE
    •  COM objects: Automation objects and ActiveX controls
      •  COM objects supported in ABL
        • ActiveX Automation objects
        • ActiveX controls
      • Support for COM object properties and methods
      • Support for Automation object events
      • Support for ActiveX control events
      •  COM object sources
        • Automation objects
        • ActiveX controls
      • Requirements for using Automation objects
      •  Requirements for using ActiveX controls
        • Design-mode requirements
        • Run-mode requirements
      • Programming requirements
    •  Sockets
      • Reasons to use sockets
      •  Connection model
        • ABL socket clients
        • ABL SSL clients
        • ABL socket servers
        • ABL SSL servers
      •  Server socket and socket objects
        • Using socket objects
      •  ABL socket event model
        • Using events to connect and communicate
      • Programming requirements
  •  System Clipboard
    •  CLIPBOARD system handle
      • AVAILABLE-FORMATS Attribute
      • ITEMS-PER-ROW Attribute
      • MULTIPLE Attribute
      • NUM-FORMATS Attribute
      • TYPE Attribute
      • VALUE attribute
    •  Single-item data transfers
      • Enabling and disabling clipboard operations
      •  Implementing single-item transfers
        • Paste operations
        • Cut operations
        • Copy operations
      • Single-item transfer example
    •  Multiple-item data transfers
      • Widget-based transfers
      • Data-based transfers
      • Multiple-item transfer example
  •  Providing Help for OpenEdge Applications
    •  Field-level online help
      •  Status messages
        • Associating help text with database fields
        • Specifying help text with ABL
        • Defining help text with the AppBuilder
      •  ToolTips
        • Implementing ToolTips with ABL
        • TOOLTIP attribute
        • TOOLTIPS attribute
        • Implementing TOOLTIPS with the AppBuilder
    •  Online help systems
      •  The SYSTEM HELP statement
        • Coding the help calling interface
      •  Accessing online help from the menu bar
        • Calling the Help Viewer
        • Calling the Index function of the Help Viewer
      • Calling online help with a Help button
      • Accessing online help with the help key
      • Quitting help when exiting the application
  •  Named Pipes
    •  Overview of named pipes with ABL
      • Access from ABL
      • Named pipes and files
      • Uses for named pipes
      •  Operational characteristics of named pipes
        • I/O synchronization
        • Message interleaving
      • Advantages and disadvantages of named pipes
    •  UNIX named pipes
      • Creating a named pipe
      • Deleting a named pipe
      • Accessing a named pipe within ABL
      •  UNIX named pipe examples
        • Example 1: creating and using a named pipe from the shell
        • Example 2: using a named pipe with ABL
    •  Windows named pipes
      • Accessing Windows named pipes
      • Linking OpenEdge and non-OpenEdge processes using Windows named pipes
      • Building and running the sample Windows named pipes application
      • Coding the ABL program
      • Coding the C program
      • Running the application
  •  Shared Library and DLL Support
    • Using shared libraries
    •  Accessing a shared library entry point
      •  Declaring a shared library for static access
        • Options for static access to a shared library routine
        • Windows DLL calling conventions for static access
      •  Declaring a shared library for dynamic access
        • Options for dynamic access to a shared library routine
    •  Passing parameters to a shared library routine
      •  Shared library parameter data types
        • Data type compatibilities
        • Other data type options
      •  Passing arrays as parameters
        • INTEGER and DECIMAL arrays
        • INT64 arrays
        • CHARACTER and LONGCHAR arrays
        • MEMPTR arrays
      • Passing the Unknown value and NULL values
      • Using structure parameters
      •  Using MEMPTR variables as parameters
        • Initializing and uninitializing MEMPTR variables
        • Passing CHARACTER values to shared library routines
        • Freeing memory associated with a MEMPTR variable
      • DLL routines and ABL widgets (Windows only)
    •  Executing a shared library routine
      •  Executing a shared library routine for static access
        • Options for shared library routine execution
      • Executing a shared library routine for dynamic access
      • Parameter data types
      • INT64 parameter conversions
    • Loading and unloading shared libraries
    •  Code samples
      • Examples of static access to a shared library
      • Examples of dynamic access to a shared library
  •  Windows Dynamic Data Exchange
    • Introduction to DDE
    •  Using the DDE protocol
      • The course of a DDE conversation
      • ABL statements for DDE conversations
    •  Structuring a DDE conversation in ABL
      • Conversation hierarchy
    •  Defining conversation endpoints: DDE frames
      • DDE-ERROR
      • Other DDE attributes
    •  Opening DDE conversations
      • Preparing the server application
      • Defining DDE frames
      • Initiating a conversation
    •  Exchanging data in conversations
      •  Demand-driven exchanges
        • Execute exchanges
        • Request and send exchanges
      •  Event-driven exchanges
        • Steps to setting up event-driven exchanges - advise links
        • Coordinating DDE client/server communications
        • Applications for event-driven exchanges
        • Multiple conversations with advise links
    • Closing DDE conversations
    • DDE example
  •  Using COM Objects in ABL
    •  How COM objects differ from ABL widgets
      • Functionality
      • ABL mechanisms
    • Obtaining access to COM objects
    •  Accessing COM object properties and methods
      •  Property and method syntax
        • Method reference
        • Property reference
        • Component handle expression
        • Method name reference
        • Property name reference
        • Data-type specifier
      •  Specifying options for properties and method parameters
        • Understanding a COM object Type Library
        • Using data-type specifier options
        • Using data-type specifiers for properties
        • Using data-type specifiers for method parameters
        • Using mode options for method parameters
      •  Restrictions on property and method references
        • Parentheses on method calls
        • Named method parameters
        • Default properties and methods
    •  Managing COM objects in an application
      • Validating component handles
      •  Managing COM object font and color settings
        • Managing fonts
        • Managing colors
      • Navigating ActiveX collections
      •  Managing COM object resources
        • Releases and deletes
        • Release strategy
        • Releases and component handles
      • Error handling
    •  Locating COM object information on your system
      • Using the COM Object Viewer
      • Accessing Type Libraries
      •  Locating objects in the Viewer
        • Automation objects
        • ActiveX controls
      • Viewing methods, properties, and events
  •  ActiveX Automation Support
    • Requirements for doing Automation
    •  Accessing Automation Servers
      • Option 1: Instantiate Automation object by name
      • Option 2: Connect to top-level named Automation object
      • Option 3: Connect to or instantiate a named Automation object and file
      • Option 4: Connect to or instantiate implied Automation object and file
    • Managing Automation objects
    • Automation event support
    • Example Automation applications
  •  ActiveX Control Support
    •  How ABL supports ActiveX controls
      • An example ActiveX control in ABL
      •  How ABL encapsulates an ActiveX control
        • Control-frame widget
        • Control-frame COM object
      • Control-frame attributes and properties
      •  Additional control functionality
        • Properties
      • Special considerations for extended controls
      • ActiveX control restrictions
    •  Creating a control instance in ABL
      • Understanding design time and runtime properties
      • Setting design time properties
      • Setting the ActiveX control name
      • Setting the control-frame name
    •  Orienting a control in the user interface at design time
      • Setting control location
      • Setting control height and width
      • Setting control tab order
      • Defining invisible controls
    •  Accessing ActiveX controls at runtime
      • Instantiating the control
      •  Accessing the control handle
        • Using the Control-Name property of the control container
        • Using the item property of the control collection
        • The handle connections
    •  Managing ActiveX controls at runtime
      • Managing tab order and Z order
      •  Working with ABL key functions
        • TAB, BACK-TAB, GO, HELP, and END-ERROR
        • RETURN and Default Buttons
      • Setting graphical properties of an ActiveX control
      •  Releasing control resources
        • Releasing ActiveX controls
        • Releasing COM objects individually
    •  Handling events
      • Handling control-frame widget events
      •  Handling ActiveX control events
        • Creating event procedures in the AppBuilder
        • Coding event procedures
        • Coding event procedure names
        • Coding event parameter definitions
        • Using system handles in OCX event procedures
        • Event handler example
      • Managing external procedure files
    •  Programming ActiveX controls in the AppBuilder
      • Creating data definitions for an ActiveX control
      • Instantiating the control
      • Initializing the control
      • Using event procedures
      • Interacting outside of event procedures
    •  ActiveX controls and examples installed with ABL
      • Combo box control (CSComboBox)
      • Spin button control (CSSpin)
      • Timer control (PSTimer)
      • Example applications using ActiveX controls
  •  Sockets
    • ABL for programming sockets
    • Overview of tasks to implement ABL sockets
    •  Implementing an ABL socket server
      • Listening and responding to connection requests
      • Managing the server socket
    • Implementing an ABL socket client
    •  Read, writing, and managing sockets on clients and servers
      • Defining and initializing MEMPTR variables
      •  Detecting data on a socket
        • Data detection using the procedural model
        • Data detection using the event-driven model
      •  Reading data on a socket
        • Specifying the read mode
        • Specifying the timeout length
        • Verifying the number of bytes actually read
      • Writing data on a socket
      • Marshalling and unmarshalling data for socket I/O
      • Managing sockets and their connections
    •  Implementing ABL socket security
      •  Configuring SSL servers and clients
        • Configuring SSL servers
        • Configuring SSL clients
      • Enabling SSL server connections
      • Connecting an SSL client to an SSL server
      •  Invoking socket operations for SSL sessions
        • Identifying the SSL server in a client session
        • Deadlocking when a non-SSL client socket connects to an SSL server socket
    • Examples using ABL sockets
  •  Host Language Call Interface
    •  HLC and OpenEdge
      • Requirements for using HLC
    • Using HLC
    •  Overview of HLC
      • Using the CALL statement
      • Mapping routine identifiers using PRODSP()
    • HLC files and directories
    •  Writing C functions
      • Top-level C function declaration
      • Returning error codes from a top-level function
      • Naming C functions
      • C function portability
    • Avoiding common HLC errors
    • Memory allocation
    • Data size
    •  Using HLC library functions
      • Accessing ABL data
      •  Data type conversion
        • Converting C language data types to ABL data types
        • Converting ABL data types to C language data types
      • Calling an HLC library function
      • Timer services
      • User interrupt handling
      • Using a library function that writes to a shared buffer
      • Passing error codes back to ABL
    • Building an HLC executable
    •  HLC applications on UNIX systems
      • Handling raw disk I/O
      •  Handling terminal I/O
        • Using the proscopn(), prosccls(), and promsgd() functions
      • Handling abnormal exits
    • Compiling C source files
    •  Example HLC application
      • Running the sample application in Windows
      • Running the sample application on UNIX
      • Source code listings
•  COM Object Data Type Mapping
  •  Data type conversion strategy
    • Converting COM to ABL data types
    • Converting ABL to COM data types
    • General conversion features and limitations
  • Conversions from COM to ABL data types
  •  Conversions from ABL to COM data types
    •  ABL to COM data type features and limitations
      • Array conversions
      • Pointer conversions
      • ABL data types not converted
  • Alternate COM data type names
•  Audit Policy Maintenance APIs
  •  API overview
    • Reference to API procedure files
    • Using the generic utility and caching APIs with an AppServer
  •  Generic utility API
    • cancel-import-from-xml procedure
    • check-conflicts procedure
    • export-audit-events procedure
    • export-cached-audit-events procedure
    • fill-audit-dataset procedure
    • getAuditEvents procedure
    • get-complete-dbname-list procedure
    • get-DB-Name function
    • get-dbname-list procedure
    • get-policies-merge procedure
    • has-DB-option function
    • isDBOnAppServer function
    • override-policies-from-xml procedure
    • policies-dataset-read-xml procedure
    • policies-dataset-write-xml procedure
    • setAppServerHandle procedure
    • updateAuditEvent procedure
    • update-auditing-policies procedure
  •  Caching API
    • changeAuditDatabase procedure
    • export-cached-audit-events procedure
    • export-policies-to-xml procedure
    • get-audit-events procedure
    • get-conflict-info procedure
    • getDataModified procedure
    • get-merge-info procedure
    • getNextAppLevelEventID function
    • hasApplEvents function
    • import-audit-events procedure
    • import-policies-from-xml procedure
    • is-valid-event-id function
    • registerAuditTableHandle procedure
    • rejectChangesAuditDatabase procedure
    • resubmit-import-from-xml procedure
    • saveAuditEventChanges procedure
    • saveChangesAuditDatabase procedure
    • set-tt-hdls-for-dataset procedure
  •  Exporting policies to XML
    • _exp-policies.p
    • _exp-policies-db.p
  •  Importing policies from XML
    • copy-changes-to-dset procedure
    • import-xml-db procedure
    • import-xml-fill-dset procedure
    • refresh-db-cache procedure
    • save-changes-to-db procedure
  •  Additional audit policy procedures
    • _aud-conflict.p
    • _get-audevents.p
    • _get-db-list.p
    • _get-policies.p
    • _update-policies.p
•  HLC Library Function Reference
  •  Function summary
    • Shared-variable access
    • Shared-buffer access
    • Screen display
    • Interrupt handling
    • Timer-service routines
  •  Function reference
    • prockint( ) - Test for Interrupt Key
    • proclear( ) - Clear the Display
    • procncel( ) - Cancel Interval Timer
    • proevt( ) - Set Interval Timer
    • profldix( ) - Return Field Handle
    • promsgd( ) - Display Message
    • prordbc( ) - Read CHARACTER Field
    • prordbd( ) - Read DATE Field
    • prordbi() - Read INTEGER Field
    • prordbl( ) - Read LOGICAL Field
    • prordbn( ) - Read DECIMAL Field
    • prordbr( ) - Read RECID Field
    • prordc( ) - Read CHARACTER Variable
    • prordd( ) - Read DATE Variable
    • prordi( ) - Read INTEGER Variable
    • prordl( ) - Read LOGICAL Variable
    • prordn( ) - Read DECIMAL Variable
    • prordr( ) - Read RECID Variable
    • prosccls( ) - Set Terminal To Raw Mode and Refresh
    • proscopn( ) - Set Terminal To Initial Mode
    • prosleep( ) - Sleep For Specified Interval
    • prowait( ) - Wait For Timer To Expire
    • prowtbc( ) - Write CHARACTER Field
    • prowtbd( ) - Write DATE Field
    • prowtbi( ) - Write INTEGER Field
    • prowtbl( ) - Write LOGICAL Field
    • prowtbn( ) - Write DECIMAL Field
    • prowtbr( ) - Write RECID Field
    • prowtc( ) - Write CHARACTER Variable
    • prowtd( ) - Write DATE Variable
    • prowti( ) - Write INTEGER Variable
    • prowtl( ) - Write LOGICAL Variable
    • prowtn( ) - Write DECIMAL Variable
    • prowtr( ) - Write RECID Variable
•  Command and Utility Reference
  • QUOTER utility
•  Database Administration Entity Interface Reference
  •  IAdministrator interface
    • IAdministrator properties
    • IAdministrator methods
    • IAdministrator examples
  •  IArea interface
    • IArea properties
    • IArea methods
    •  IArea examples
      • Creating areas
      • Updating areas used for extents
  •  IAuthenticationSystem interface
    • IAuthenticationSystem properties
    • IAuthenticationSystem methods
    •  IAuthenticationSystem examples
      • Creating an authentication system
      • Updating an existing authentication system
  •  IDataAdminElement interface
    • IDataAdminElement properties
    • IDataAdminElement methods
    • IDataAdminElement examples
  •  IDomain interface
    • IDomain properties
    • IDomain methods
    •  IDomain examples
      • Creating a new domain
      • Editing properties on an existing domain
      • Adding users to an existing domain
  •  IExtent interface
    • IExtent properties
    • IExtent methods
    • IExtent examples
  •  IField interface
    • IField properties
    • IField methods
  •  IFieldPermission interface
    • IFieldPermission properties
    • IFieldPermission methods
    • IFieldPermission examples
  •  IIndex interface
    • IIndex properties
    • IIndex methods
  •  IIndexField interface
    • IIndexField properties
  •  IPartition interface
    • IPartition properties
    • IPartition methods
    • IPartition examples
  •  IPartitionOwner interface
    • IPartitionOwner properties
    • IPartitionOwner methods
  •  IPartitionParent interface
    • IPartitionParent properties
  •  IPartitionPolicy interface
    • IPartitionPolicy properties
    • IPartitionPolicy methods
    •  IPartitionPolicy examples
      • Creating a partition policy for an empty table
      • Editing an existing partition policy
      • Creating a policy for a table with data
      • Renaming a partition policy
  •  IPartitionPolicyDetail interface
    • IPartitionPolicyDetail properties
    • IPartitionPolicyDetail methods
    •  IPartitionPolicyDetail examples
      • Creating a new partition detail
      • Finding by name
      • Finding last by value
      • Renaming of a partition policy detail
      • Setting a partition policy detail as read-only
  •  ISchema interface
    • ISchema properties
    • ISchema methods
    • ISchema examples
  •  ISchemaElement interface
    • ISchemaElement properties
    • ISchemaElement methods
  •  ISequence interface
    • ISequence properties
    • ISequence methods
    •  ISequence examples
      • Creating a sequence
      • Setting properties for an existing sequence
  •  ISequenceValue interface
    • ISequenceValue properties
    • ISequenceValue methods
    •  ISequenceValue examples
      • Changing the current value of a sequence for a specific tenant
      • Changing the current value of sequence in a tenant's sequence collection
  •  ITable interface
    • ITable properties
    • ITable methods
    •  ITable examples
      • Allocating table partitions
      • Managing partitions for a table
  •  ITablePermission interface
    • ITablePermission properties
    • ITablePermission methods
    • ITablePermission examples
  •  ITenant interface
    • ITenant properties
    • ITenant methods
    •  ITenant examples
      • Creating and editing a tenant
      • Adding domains to a tenant
      • Adding tenant groups to a tenant
      • Managing partitions for a tenant
  •  ITenantGroup interface
    • ITenantGroup properties
    • ITenantGroup methods
    •  ITenantGroup examples
      • Creating and editing a tenant group
      • Adding tenants to a tenant group
      • Managing partitions for a tenant group
  •  IUser interface
    • IUser properties
    • IUser methods
    •  IUser examples
      • Creating and editing a user
      • Editing an existing user
  •  IUserFieldPermission interface
    • IUserFieldPermission properties
    • IUserFieldPermission methods
  •  IUserPermission interface
    • IUserPermission properties
    • IUserPermission methods
  •  IUserTablePermission interface
    • IUserTablePermission properties
    • IUserTablePermission methods
•  Database Administration Entity Collection Interface Reference
  • Collection interface naming conventions
  • Common collection features
  •  IAreaSet interface
    • IAreaSet properties
    • IAreaSet methods
  •  IAuthenticationSystemSet interface
    • IAuthenticationSystemSet properties
    • IAuthenticationSystemSet methods
  •  IDataAdminCollection interface
    • IDataAdminCollection properties
    • IDataAdminCollection methods
  •  IDomainSet interface
    • IDomainSet properties
    • IDomainSet methods
  •  IExtentList interface
    • IExtentList properties
    • IExtentList methods
  •  IFieldPermissionSet interface
    • IFieldPermissionSet properties
    • IFieldPermissionSet methods
  •  IFieldSet interface
    • IFieldSet properties
    • IFieldSet methods
  •  IIndexSet interface
    • IIndexSet properties
    • IIndexSet methods
  •  IIterator interface
    • IIterator methods
    • Examples for using the Iterator method
  •  IPartitionCollection interface
    • IPartitionCollection properties
    • IPartitionCollection methods
  •  IPartitionMap interface
    • IPartitionMap properties
    • IPartitionMap methods
  •  IPartitionPolicyDetailSet interface
    • IPartitionPolicyDetailSet properties
    • IPartitionPolicyDetailSet methods
  •  IPartitionPolicySet interface
    • IPartionPolicySet properties
    • IPartionPolicySet methods
  •  ISchemaPartitionMap interface
    • ISchemaPartitionMap properties
    • ISchemaPartitionMap methods
  •  ISequenceSet interface
    • ISequenceSet properties
    • ISequenceSet methods
  •  ISequenceValueMap interface
    • ISequenceValueMap properties
    • ISequenceValueMap methods
  •  ITablePermissionSet interface
    • ITablePermissionSet properties
    • ITablePermissionSet methods
  •  ITableSet interface
    • ITableSet properties
    • ITableSet methods
  •  ITenantGroupSet interface
    • ITenantGroupSet properties
    • ITenantGroupSet methods
  •  ITenantSet interface
    • ITenantSet properties
    • ITenantSet methods
  •  IUserFieldPermissionSet interface
    • IUserFieldPermissionSet properties
    • IUserFieldPermissionSet methods
  •  IUserPermissionSet interface
    • IUserPermissionSet properties
    • IUserPermissionSet methods
  •  IUserSet interface
    • IUserSet properties
    • IUserSet methods
  •  IUserTablePermissionSet interface
    • IUserTablePermissionSet properties
    • IUserTablePermissionSet methods