Application Development on AS ABAPABAP Programming LanguageABAP Programming (BC-ABA)Introduction to ABAPSAP NetWeaver Application Server ABAPOverview of NetWeaver AS ABAPABAP Application ServerWork ProcessesThe Components of ABAP Application ProgramsApplication Programs on NetWeaver AS ABAPUser InterfacesABAP Programming ModelsObject-Oriented Programming ModelProcedural Programming ModelStructure of the Processing LogicProcessing Blocks in ABAP ProgramsProgram Types and ExecutionDialog ProgrammingReport ProgrammingCreating and Changing ABAP ProgramsOpening Programs in the Object NavigatorOpening Programs in the ABAP EditorOpening Programs Using Forward NavigationMaintaining Program AttributesEditing ProgramsProgram ChecksThe ABAP Programming LanguageABAP SyntaxSyntax ConventionsABAP Statements – an OverviewIntroductory Statements for ProgramsData Types and Data ObjectsData TypesDefinition and Visibility of Data TypesCompatibilityData ObjectsLiteralsText SymbolsVariablesConstantsInterface Work AreasDetermining the Attributes of Data ObjectsBuilt-In Data Types and Data ObjectsPredefined ABAP TypesData Types in the ABAP DictionaryPredefined Data ObjectsGeneric Data Types for TypingLocal Data Types and Data Objects in a ProgramThe Statements TYPES and DATASelf-Defined Elementary Data Types and Data ObjectsReference Types and Reference VariablesSelf-Defined Complex Data TypesStructured Data TypesSelf-Defined Table TypesOperations on Data ObjectsAssigning ValuesAssigning Values with MOVEResetting Variables to Their Initial ValueType ConversionsAssignment Rules for Reference VariablesConversion Rules for StructuresConversion Rules for Internal TablesAlignment of Data ObjectsNumeric operationsArithmetic CalculationsMathematical functionsBusiness CalculationsDate and Time CalculationsControlling the Program FlowLogical ExpressionsComparisons for Operands of Arbitrary Data TypesComparisons Between Character Strings and Byte StringsComparisons Between Bit SamplesChecking RequirementsCombining Several Logical ExpressionsControl StructuresBranching ConditionallyLoopsDealing with ExceptionsClass-Based ExceptionsOverview of Class-Based ExceptionsHandling ExceptionsRaising ExceptionsPropagating ExceptionsDefining ExceptionsException TextsPrevious ConceptsExceptions in Function Modules and MethodsCatchable Runtime ErrorsByte and Character String ProcessingProcessing Character StringsSearching Within Character StringsReplacements in Character StringsMoving Field Contents Character by CharacterConcatenating Character StringsSplitting Character StringsConverting to Upper or Lower Case or Replacing CharactersConverting into a Sortable FormatOverlaying Character FieldsCondensing Field ContentsObsolete Statements for Character StringsProcessing Byte StringsSetting and Reading BitsBit OperationsSet Operations Using Bit SequencesProcessing SubfieldsDetermining LengthField Symbols and Data ReferencesField SymbolsDeclaring Field SymbolsAssigning Data Objects to Field SymbolsBasic Forms of the ASSIGN StatementAssigning Components of Structures to a Field SymbolCasting Data ObjectsObsolete CastingData Areas for Field SymbolsData ReferencesReference VariableCreating Data Objects DynamicallyGetting References to Data ObjectsDereferencing Data ReferencesData References: ExampleInternal Tables and ExtractsInternal TablesCreating Internal TablesTable typesInternal TablesSpecial Features of Standard TablesProcessing Internal TablesOperations on Entire Internal TablesAssigning Internal TablesInitializing Internal TablesComparing Internal TablesSorting Internal TablesInternal Tables as Interface ParametersDetermining the Attributes of Internal TablesOperations on Individual LinesAccess Methods to Individual Table EntriesAccess Using Field SymbolsFilling Internal Tables Line By LineInserting Lines into TablesAppending Summarized LinesAppending Table LinesReading Lines of TablesBinary Search in Standard TablesProcessing Table Entries in LoopsChanging LinesDeleting LinesSearching Through Internal Tables Line By LineSearching through Table RowsSearching Through and Replacing Table RowsObsolete Statements for Internal TablesUsing Header Lines as Work AreasExtractsDefining an ExtractFilling an Extract with DataProcessing ExtractsReading an ExtractSorting an ExtractControl Level ProcessingCalculating Numbers and TotalsFormatting dataExample of Formatted DataFormatting Data During ReadingRefining Data Using Internal TablesFormatting Data Using ExtractsSaving Data ExternallyDatabase AccessesDatabase Accesses of the NetWeaver AS ABAPOpen SQLReading DataDefining a SelectionSpecifying a Target AreaSpecifying Database TablesSelecting LinesGrouping LinesSelecting Groups of LinesSpecifying a Sort OrderSubqueriesUsing a Cursor to Read DataPossible Conflicting LocksChanging DataInserting Lines into TablesChanging LinesDeleting LinesInserting or Changing LinesCommitting Database ChangesPerformance NotesKeep the Result Set SmallMinimize the Amount of Data TransferredMinimize the Number of Data TransfersMinimize the Search OverheadReducing the Database LoadNative SQLNative SQL for OracleNative SQL for InformixNative SQL for DB2 Common ServerData InterfacesWorking with Files on the Application ServerAutomatic Checks in File OperationsAuthorization Checks for Programs and FilesGeneral Checks for File AccessWorking with Files on the Presentation ServerUsing Platform-Independent FilenamesData ClustersStorage Media for Data ClustersStatements for Data ClustersData ConsistencyTransactions and Logical Units of WorkDatabase Logical Unit of Work (LUW)SAP LUWSAP TransactionsChecking AuthorizationsAuthorization ConceptAuthorizationThe SAP Lock ConceptExample Program: SAP LockingUpdate TechniquesAsynchronous UpdateUpdating Asynchronously in StepsSynchronous UpdateLocal UpdateCreating Update Function ModulesCalling Update FunctionsCalling Update Functions DirectlyAdding Update-Task Calls to a SubroutineSpecial LUW ConsiderationsTransactions That Call Update Function ModulesDialog Modules that Call Update Function ModulesError Handling for Bundled UpdatesObsolete TechniquesUsing ContextsWhat Are Contexts?The Context Builder in the ABAP WorkbenchCreating and Editing a ContextUsing Tables as ModulesUsing Function Modules as ModulesUsing Contexts as ModulesTesting a ContextBuffering ContextsFieldsModulesInterfacesUsing Contexts in ABAP ProgramsFinding and Displaying a ContextCreating an Instance of a ContextSupplying Context Instances with Key ValuesQuerying Data from Context InstancesMessage Handling in ContextsMessage Handling in Table ModulesMessage Handling in Function Module ModulesHints for Working With ContextsLogical DatabasesStructure of Logical DatabasesSelection ViewsExample of a Logical DatabaseUsing Logical DatabasesLinking a Logical Database to an Executable ProgramCalling a Logical Database Using a Function ModuleEditing Logical DatabasesCreating a Logical DatabaseEditing the StructureEditing a Search HelpEditing SelectionsEditing the Database ProgramDynamic Selections in the Database ProgramField Selections in the Database ProgramSearch Helps in the Database ProgramIndependent Calls and the Database ProgramEditing Other ComponentsImproving PerformanceListsCreating ListsCreating Simple Lists with the WRITE StatementThe WRITE StatementPositioning WRITE Output on the ListFormatting OptionsDisplaying Symbols and Icons on the ListLines and Blank LinesDisplaying Field Contents as CheckboxesUsing WRITE via a Statement StructureCreating Complex ListsThe Standard ListStructure of the Standard ListGUI Status of the Standard ListThe Self-Defined ListIndividual Page HeaderDetermining the List WidthCreating Blank LinesDetermining the Page LengthDefining a Page FooterLists with Several PagesProgramming Page BreaksStandard Page Headers of Individual PagesPage length of individual pagesPage Width of List LevelsScrolling in ListsScrolling Window by WindowScrolling by PagesScrolling to the List's MarginsScrolling by ColumnsDefining Where the User Can Scroll on a PageLaying Out List PagesPositioning the OutputAbsolute PositioningRelative PositioningFormatting OutputThe FORMAT StatementColors in ListsEnabling Fields for InputOutputting Fields as HotspotsSpecial Output FormatsLines in ListsInteractive ListsDetails ListsDialog Status for ListsContext Menus for ListsList Events in an ABAP ProgramLists in Dialog BoxesPassing Data from Lists to ProgramsPassing Data AutomaticallyPassing Data by Program StatementsManipulating Detail ListsScrolling in Detail ListsSetting the Cursor from within the ProgramModifying List LinesLists and ScreensStarting Lists from Screen ProcessingCalling Screens from List ProcessingPrinting and Storing ListsPrinting a List After Creating ItPrinting a List While Creating ItPrint ParametersExecute and PrintPrinting from within the ProgramPrinting Lists from a Called ProgramPrint ControlDetermining Left and Upper MarginsDetermining the Print FormatArchiving Lists Using SAP ArchiveLinkABAP User InterfacesGeneral ScreensScreen ElementsScreen AttributesScreen ElementsScreen FieldsScreen Flow LogicProcessing ScreensUser Actions on ScreensProcessing Input/Output FieldsPushbuttons on the ScreenCheckboxes and Radio Buttons with Function CodesUsing GUI StatusesReading Function CodesFinding Out the Cursor PositionCalling ABAP Dialog ModulesSimple Module CallsControlling the Data TransferCalling Modules UnconditionallyConditional Module CallsInput checksAutomatic Input ChecksChecking Input in the Screen Flow LogicInput Checks in Dialog ModulesField Help, Input Help, and Dropdown BoxesField helpInput HelpInput Help from the ABAP DictionaryInput Help on the ScreenInput Help in Dialog ModulesDropdown BoxesModifying Screens DynamicallySetting Attributes DynamicallyThe Field Selection FunctionSetting the Cursor PositionSwitching on Hold Data DynamicallyScreen SequencesStatic Next ScreenDynamic Next ScreenLeaving a Screen from a ProgramCalling a Screen SequenceEmbedding Modal Dialog BoxesScreen Sequences: Example TransactionFilling an Initial Screen Using SPA/GPA ParametersComplex Screen ElementsStatus iconsContext MenusSubscreensTabstrip controlsCustom ControlsTable ControlsTable Controls on the ScreenTable Controls in the Flow LogicTable Controls in ABAP ProgramsTable Controls: Examples with ScrollingTable Controls: Examples with ModificationsAppendix: The Step Loop TechniqueSelection ScreensSelection Screens and Logical DatabasesDefining Selection ScreensDefining Input Fields for Single ValuesBasic Form of ParametersDynamic Dictionary ReferenceDefault Values for ParametersSPA/GPA Parameters as Default ValuesAllowing Parameters to Accept Upper and Lower CaseReducing the Visible LengthDefining Required FieldsSearch Helps for ParametersChecking Input ValuesDefining CheckboxesDefining Radio ButtonsHiding Input FieldsModifying Input FieldsDefining Complex SelectionsSelection TablesBasic Form of Selection CriteriaSelection Criteria and Logical DatabasesDefault Values for Selection CriteriaRestricting Entry to One RowRestricting Entry to Single FieldsAdditional Options for Selection CriteriaFormatting Selection ScreensBlank Lines, Underlines, and CommentsSeveral Elements in a Single LineBlocks of ElementsCalling Selection ScreensCalling Standard Selection ScreensCalling User-Defined Selection ScreensUser Actions on Selection ScreensPushbuttons on the Selection ScreenCheckboxes and Radio Buttons with Function CodesPushbuttons in the Application ToolbarChanging the Standard GUI StatusSelection screen processingBasic FormPBO of the Selection ScreenProcessing Single FieldsProcessing BlocksProcessing Radio ButtonsProcessing Multiple SelectionsDefining Field HelpDefining Input HelpSubscreens and Tabstrip Controls on Selection ScreensSelection Screens as SubscreensTabstrip Controls on Selection ScreensSubscreens on Selection ScreensUsing Selection CriteriaSelection Tables in the WHERE ClauseSelection Tables in Logical ExpressionsSelection Tables in GET EventsMessagesMessage ManagementMessagesMessage ProcessingMessages Without ScreensMessages on ScreensMessages on Selection ScreensMessages in ListsMessages in Function Modules and MethodsExecuting ABAP Program UnitsSummary of Callable UnitsABAP ProgramsProceduresScreens and Screen SequencesCalling ProgramsProgram Calls - OverviewCalling Executable ProgramsFilling the Selection Screen of a Called ProgramAffecting Lists in Called ProgramsProgram Statements to Leave a Called ProgramDirect executionLinking to a Logical DatabaseEvent Blocks in Executable ProgramsDescription of Reporting EventsINITIALIZATIONAT SELECTION-SCREENSTART-OF-SELECTIONGETGET ? LATEEND-OF-SELECTIONExiting Event BlocksExiting Event Blocks Using STOPExiting Event Blocks Using EXITLeaving Event Blocks Using CHECKLeaving a GET Event Block Using REJECTTransactionsCalled by the User (Transactions Code)Sample TransactionCalling TransactionsCalling Screen Sequences as ModulesPassing Data Between ProgramsModularization TechniquesDefining Processing BlocksEvent BlocksDialog ModulesProceduresDefining SubroutinesGlobal Data from the Framework ProgramLocal Data in the SubroutineThe Parameter InterfaceFunction ModulesFunction GroupsCreating Function ModulesSource Code ModulesMacrosInclude ProgramsCalling ProceduresCalling Procedures - OverviewInternal Procedure CallsExternal Procedure CallsOrganization of External Procedure CallsCalling SubroutinesNaming SubroutinesPassing Parameters to SubroutinesExamples of SubroutinesShared Data AreasTerminating SubroutinesCalling Function ModulesABAP ObjectsWhat is Object Orientation?From Function Groups to ObjectsInstances of Function Groups: ExampleClassesClasses: Overview GraphicClasses - Introductory ExampleObject HandlingObjects: Overview GraphicObjects - Introductory ExampleDeclaring and Calling MethodsMethods in ABAP Objects - ExampleInheritanceInheritance: Overview GraphicInheritance: Introductory ExampleInterfacesInterfaces: Overview GraphicInterfaces - Introductory ExampleTriggering and Handling EventsEvents: Overview GraphicEvents: Introductory ExampleEvents: Complex ExampleClass and Interface PoolsOO TransactionsABAP and UnicodeCharacter CodesABAP Development in UnicodeConcepts and ConventionsData TypesData Layout of StructuresUnicode Fragment ViewValid CharactersRestrictions in Unicode ProgramsCharacter-Type and Numeric OperandsAccess Using Offset and Length SpecificationsAssignmentsComparisonsProcessing StringsType Checks and Type CompatibilityChanges to Database OperationsDetermining the Length and DistanceStructure EnhancementsOther ChangesNew ABAP Statements for UnicodeString Processing for Byte StringsDetermining the Length and DistanceAssignments to Field SymbolsIncludes with Group NamesCreating Data Objects DynamicallyAssigning Fields DynamicallyStoring Data as ClustersFile interfaceFiles on the Presentation ServerGeneric Types for Field Symbols and ParametersFormatting ListsNew Classes for UnicodeDetermining Field PropertiesConverting DataRFC and UnicodeFurther MeasuresExamplesAssignment Between Structures IAssignment Between Structures IIAssignments Between Structures IIIAssignments Between Structures IVAssignment Between Structure and Single Field IAssignment Between Structure and Single Field IIAssignment Between Structure and Single Field IIIAssignment Between Structure and Single Field IIIAssignment Between Structure and Single Field VCharacter String ProcessingFile InterfaceOutputting ListsUnicode GlossaryAppendixScreens and Processing BlocksABAP System FieldsABAP Programming TechniquesABAP - Shared ObjectsShared Objects - ImplementationShared Objects - Notes on UsageShared Objects - AreasShared Objects – Area PropertiesBasic PropertiesArea NameArea Root ClassClient-Dependent AreaAutomatic Area BuildingTransactional AreaFixed Area PropertiesArea BindingArea Instance VersioningDynamic Area PropertiesArea Constructor ClassDisplacement TypeRuntime-dependent Area PropertiesArea Build TypeSize of an Area Instance VersionNumber of Versions of an Area InstanceLifetime of an Area InstanceShared Objects - Transaction SHMADisplay, Change and Create AreasMaintain Runtime PropertiesDisplay Runtime PropertiesChange Runtime PropertiesDelete Runtime PropertiesAdditional FunctionsShared Objects - AccessShared Objects – Access to Area InstancesShared Objects - LocksShared Objects – States of Area Instance VersionsShared Objects Monitor - Transaction SHMMShared Objects - Working with ObjectsShared Memory-enabled ClassesReferencesRoot ObjectObject CreationBehandlung von SpeicherengpässenShared Objects - ClassesCL_ABAP_MEMORY_AREACL_SHM_AREAArea Class <area>CL_IMODE_AREAIF_SHM_BUILD_INSTANCE<area_constructor> Area Constructor ClassShared Objects - TermsShared Objects - ExampleABAP - Object ServicesThe Persistence ServiceConcepts Used in PersistenceComponents of the Persistence ServiceManagement States of an ObjectMappingMapping by Business KeyMapping by Instance-GUIDMapping by Instance-GUID and Business KeyInheritance in Persistent ClassesSaving Object References PersistentlyPersistent Objects and COMMIT WORKThe Persistence Service During UpdatesTransaction ServiceTransaction Service and SAP Transaction ConceptComponents of the Transaction ServiceTransaction ModeNesting and ConcatenationInteraction between Classical and Object-Oriented TransactionsCheck AgentsQuery ServiceConcepts Used in QueriesFilter ConditionSort ConditionQuery Service ComponentsDealing with ExceptionsWorking with Persistent Objects: ExamplesGenerating a Persistent ObjectObject-Oriented Transaction ModeUsing a QueryProgramming with the Background Processing System (BC-CCM-BTC)Programming TechniquesScheduling and Managing a Job: Easy MethodEasy Job Scheduling Using BP_JOBVARIANT_SCHEDULEManaging “Easy-Method” Jobs with BP_JOBVARIANT_OVEScheduling a Job: Full-Control MethodTask Overview: Full-Control Job SchedulingWhere to Specify Job AttributesGetting Job-Start Specifications from UsersCalculating Start Dates for Periodic JobsObtaining Printing and Archiving SpecificationsSample Program: Declarations, Set Up, and Print SpecificationsSample Program: Creating a Job with JOB_OPENSample Program: Adding an ABAP Job StepSample Program: Adding a Job Step for an External Command or ProSample Program: Adding a Job Step with ABAP SUBMISample Program: Immediate Start with JOB_CLOSESample Program: Immediate Start with Spool RequesSample Program: Start-Time Window with JOB_CLOSESample Program: Job Start on Workday (JOB_CLOSE)Sample Program: Job Start on Event (JOB_CLOSE)Sample Program: Wait for Predecessor Job with JOBSample Program: Start at Switch to Operating Mode (JOB_CLOSE)Job Outcomes: Displaying Job LogsDisplaying a Job LogCopying a Job Log into an Internal TableManaging Jobs: Generating Job ListsSample Program: Generating a Job ListDisplaying Job Status: SHOW_JOBSTATESelecting and Deleting a JobWorking with EventsEvent ConceptsUsing Events: Task OverviewDefining EventsTriggering Events from ABAP ProgramsTriggering Events from External ProgramsFinding Out Which Event and Argument Were TriggereRunning External ProgramsImplementing Parallel ProcessingSpecial Techniques: Starting External ProgramsAdvanced Scheduling 1: Building Chains of JobsAdvanced Scheduling 2: Scheduling and SynchroniziAdvanced Scheduling 3: Deciding Which Job to ScheReference: Background Processing Function ModulesJOB_OPEN: Create a Background Processing JobJOB_SUBMIT, ABAP SUBMIT: Add a Job Step to a JobJOB_CLOSE: Pass a Job to the Background ProcessinBP_JOBVARIANT_SCHEDULE and BP_JOBVARIANT_OVERVIEW:BP_CALCULATE_NEXT_JOB_STARTS: Determine Start DatBP_CHECK_EVENTID: Check that an Event ExistsMethod RAISE: Trigger an Event from an ABAP ProgramBP_JOB_COPY: Copy a Background JobBP_JOB_DELETE: Delete a Background Processing JobBP_JOB_GET_PREDECESSORS: List Predecessor-Jobs ofBP_JOB_GET_SUCESSORS: List the Successor-Jobs ofBP_JOB_MAINTENANCE: Job Management FunctionsBP_JOB_SELECT: Read Jobs from DatabaseBP_FIND_JOBS_WITH_PROGRAM: Read Jobs that Run a SBP_JOBLIST_PROCESSOR: Allow User to Work with List of JobsSHOW_JOBSTATE: Check Status of a JobBP_JOBLOG_READ: Read a Job Log for ProcessingBP_JOBLOG_SHOW: Display a Job Processing LogBP_START_DATE_EDITOR: Display/Request Start SpeciBP_JOB_READ: Retrieve Job SpecificationsSHOW_JOBSTATE: Display Job StatusParallel-Processing Function ModulesData TransferData Transfer MethodsData Transfer: Overview of Batch InputThe Transaction RecorderRecording TransactionsRecordingUsing the Recording EditorGenerating Batch Input Sessions From the RecordingGenerating Data Transfer ProgramsGenerating Function ModulesUsing Function ModulesCreating Test FilesExecuting the Data TransferWriting Data Conversion ProgramsGenerating an SAP Data Structure for the ConversioData ConversionFilling SAP Data StructuresSelecting a Data Transfer MethodExecuting Data Transfer ProgramsBatch Input AuthorizationsAdditional InformationUsing CALL TRANSACTION USING for Data TransferCreating Batch Input SessionsCreating a Session with BDC_OPEN_GROUPAdding Data to a Session: BDC_INSERTClosing a Session: BDC_CLOSE_GROUPProcessing Batch Input SessionsUsing CALL DIALOG with Batch InputUsing the Data Transfer Data StructureDetermining System DataFrequent Data Transfer ErrorsDirect InputProgramming with External CommandsProgramming TechniquesSXPG_CALL_SYSTEM: Run an External Command (Express Method)SXPG_COMMAND_EXECUTE: Check Authorization for and Execute an ExSXPG_COMMAND_CHECK: Check Authorization to Execute an ExternalSXPG_COMMAND_LIST_GET: Read a List of External CommandsSXPG_COMMAND_DEFINITION_GET: Read Single External CommandSXPG_DUMMY_COMMAND_CHECK: Interface for Extra-Check Function MoCommon Application InterfacesABAP Programming ToolsABAP Workbench ToolsOverview of the ABAP WorkbenchLearning MoreObject NavigatorNavigationSwitching Between BrowsersNavigation StackNavigation ContextRepository BrowserSelecting an ObjectObject List ToolbarCreating a New ObjectCreating a ProgramCopying an ObjectDeleting an ObjectAssigning an Object to a Different PackageCreating a Transport EntryActivating an ObjectUsing Set ModeUser-Specific SettingsWorklistSetting MarkersABAP EditorFront-End Editor (Source Code Mode)Editing FeaturesSyntax HighlightingCode HintsCode CompletionCode TemplatesAutomatic Brace and Structure MatchingBlock SelectionFormattingAdditional Editing FeaturesDisplay FeaturesWindow SplitterActive Status BarCode Outlining and StructuringMouse Pointer and Caret StylesFind and ReplaceIncremental SearchClipboard RingNavigationBookmarksPrintingExport FunctionalitySettingsDisplay SettingsFont and Color SettingsCode Completion SettingsCode Template SettingsFormatting SettingsAuto Correction SettingsKeyboard SettingsDefault Key CombinationsPrint SettingsXML SettingsChanging the Editor ModeCreating a ProgramEditing a ProgramSaving and Activating a ProgramChecking a ProgramExtended Program CheckErrors and WarningsOverview of Former Editor ModesFront-End Editor (Plain Text Mode)Back-End EditorEditing a Program (Former Editor Modes)Navigating in the Source CodeNavigating by Double-ClickUsing Compression LogicEditing Source Code (Front-End Editor)Editing Source Code (Back-End Editor)Using BuffersFind and Replace (Front-End Editor)Find and Replace (Back-End Editor)Inserting Statement PatternsInserting Statement Patterns by Drag and DropExpanding IncludesUsing ABAP HelpLocal EditingImproving the LayoutFeatures of the Pretty PrinterFunction BuilderOverview of Function ModulesLooking Up Function ModulesInterface Parameters of a Function ModuleCalling Function Modules From Your ProgramsCreating New Function ModulesCreating a Function GroupCreating a Function ModuleSpecifying Parameters and ExceptionsUnderstanding Function Module CodeChecking and Activating Function ModulesTesting Function ModulesSaving Tests and Test SequencesDocumenting and Releasing a Function ModuleClass BuilderForm-Based Class BuilderSource Code-Based Class BuilderCreating Classes and InterfacesCreating a Standard ClassClass-Based ExceptionsCreating an Exception ClassCreating a Persistent ClassGenerated ClassesCreating an InterfaceMaintaining Standard ClassesCreating AttributesVisibility Sections in ClassesCreating and Defining MethodsCreating Parameters for MethodsCreating Exceptions for MethodsImplementing MethodsCreating Event Handler MethodsCreating EventsCreating TypesCreating Local Definitions and ImplementationsLocal Definitions not Referred by the Global ClassLocal Definitions Referred by the Global ClassLocal Test ClassesMacros (Obsolete)Activating Classes and InterfacesMaintaining Persistent ClassesThe Mapping AssistantDefining Persistence RepresentationDefining Value Attributes, Key Attributes, and GUIDsDefining Reference AttributesClass Diagram: Persistence RepresentationActivating Persistent ClassesEditing Persistent AttributesMaintaining Global Exception ClassesCreating Attributes for Exception ClassesCreating Exception Texts in the Online Text RepositoryInserting Exception Texts from Message ClassesDefining Relationships Between Object TypesEnhancing Classes with InterfacesCreating a SubclassExtending a SubclassNesting InterfacesDefining a Friends RelationshipLocking a Class for EditRefactoringMoving Components to a SuperclassMoving Components to a SubclassMoving Components to an InterfaceMoving Components to Associated ClassesMoving Interfaces to a SuperclassMoving Interfaces to a SubclassMoving Interface Components in ClassesMoving Interface Components to a Component InterfaceSplitting ClassesSplitting InterfacesTestingTesting a ClassCreating InstancesTesting AttributesTesting MethodsTesting Event HandlingTesting an Interface View of an ObjectEnhancements to Classes and InterfacesEnhancing the Components of Classes or InterfacesSettings of the Class BuilderNaming Conventions in ABAP ObjectsRefactoring AssistantConsistent RenamingRenaming Local ElementsRenaming Global ElementsExtracting Source Code SegmentsRemoving Unused Data DeclarationsInserting GET and SET MethodsScreen PainterCreating a ScreenMaintaining Screen AttributesCreating Flow LogicFlow Logic KeywordsScreen ElementsGraphical Layout EditorDesigning the Screen LayoutBasic Operations with Screen ElementsInserting FieldsUsing IconsUsing Radio ButtonsTabstrip ControlsCreating a Tabstrip ControlTabstrip Control WizardTable ControlsCreating a Table ControlTable Control WizardEditing a Table ControlCreating a Custom ContainerStep LoopsElement List in Graphical ModeAlphanumeric Fullscreen EditorCreating Screen ElementsAdding Dictionary and Program Fields to a ScreenCreating a Table ControlCreating a Tabstrip ControlCreating a Custom ContainerCreating a Step LoopModifying Screen ElementsConverting ElementsElement ListMaintaining Attributes for Screen ElementsGeneral AttributesDictionary AttributesProgram AttributesDisplay AttributesTabstrip Control AttributesTable Control AttributesAttributes of the Subscreen AreaCustom Container AttributesField FormatsTesting ScreensChecking ScreensSaving, Activating, and Deleting ScreensMenu PainterBasic ConceptsThe GUI StatusThe Dialog StatusFunctionsSpecial Function Keys and Function CodesContext MenusUsing the Menu PainterThe Interface of the Menu PainterCreating a GUI TitleDefining a StatusCreating a GUI StatusCreating a Context MenuMenu BarsCreating a Menu BarAdding Functions to a MenuDefining Function Key SettingsDefining an Application ToolbarDefining Icons and Info Texts in the Application ToolbarDisplaying Inactive FunctionsInserting SeparatorsCreating the Standard ToolbarTesting and Activating a StatusUsing the Ergonomics CheckCopying a StatusLinking Objects in a GUI StatusOverview ListsUsing FunctionsFunction TypesDefining Function TypesDefining a FastpathActivating and Deactivating Function CodesDeactivating Functions at RuntimeDefining Dynamic Function TextsChanging Function TextsDefining Dynamic Menu TextsSetting a GUI Status and a GUI TitleEvaluating Function Codes in the ProgramSplitscreen EditorStarting the Splitscreen EditorSplitscreen Editor FunctionsABAP Editor Functions in the Splitscreen EditorTransformation EditorCreating a Transformation ProgramTesting a Transformation ProgramCreating Breakpoints in XSLT ProgramsXSLT DebuggerStarting and Exiting a Debugging SessionUser Interface of the XSLT DebuggerResult ViewBreakpoint ViewCall ViewVariable ViewBreakpointsCreating Breakpoints in XSLT ProgramsSaving BreakpointsDeleting BreakpointsWays of DebuggingXSLT Debugger and ABAP DebuggerWeb Dynpro in the ABAP WorkbenchGo and Create First Application with Web Dynpro ABAPStep 1: Creating and Editing a ComponentStep 2: Structuring the First ViewStep 3: Context Mapping of the First ViewStep 4: Binding the AttributeStep 5: Designing the Second ViewStep 6: Maintaining the Context of the Second ViewStep 7: Embedding the View in a WindowStep 8: Defining NavigationStep 9: Creating and Testing a Web Dynpro ApplicationCreating a Simple Flight Info ApplicationPart 1: Creating and Editing the Search ViewPart 2: Testing the First ViewPart 3: Creating and Editing the "Display ViewPart 4: Implementing the Data TransportPart 5: Setting Up NavigationWeb Dynpro Tools in the ABAP WorkbenchComponent EditorController EditorController PropertiesController ContextCreating and Maintaining Context NodesCreating and Maintaining Context AttributesDefining a MappingController AttributesController EventsController: MethodsView EditorView Layout (View Designer)View: Inbound and Outbound PlugsView: Components of a View ControllerWindow EditorWindow: View HierarchyWindow: Inbound and Outbound PlugsNavigation Links of a Windows Outbound PlugsWindow: Components of a Window ControllerDisplaying an Interface ViewDisplaying and Defining the Interface ControllerWeb Dynpro ApplicationWeb Dynpro Code WizardScreen Design Time ConversionRestrictionsTransformation RulesLayout ManagementDynpro ControlsCheckboxFrameI/O FieldPushbuttonRadio ButtonStep LoopSubscreenTable ControlTabStripText FieldWeb Dynpro Text BrowserWeb Dynpro ABAP Runtime AnalysisMemory AnalysisPackage Assignment and Transport EntryRefactoring for Web Dynpro ABAPWeb Application Builder for BSPsIntroductionStructure of a BSP ApplicationEvent HandlerPage AttributesGlobal ObjectsBasic FunctionsCreating BSP ApplicationsCreating PagesCreating a ControllerCreating Error PagesDetermining the Page FlowCreating References to MIMEsActivating BSP ApplicationsExecuting BSP ApplicationsModel View Controller (MVC)MVC Design PatternUsing MVC for BSPCreating a ControllerCreating a ViewTesting ControllersCalling (Sub) ControllersCalling a ViewCreating Error PagesFrom Pages to ControllersCall Options of BSP ComponentsNavigationLifetimeData BindingCalling the Model Class by the ControllerComponentsProcess FlowCreating Your Own ComponentsCreating the Top-Level ControllerCreating ComponentsCalling ComponentsDetermining Input ProcessingClass CL_BSP_CONTROLLER2Examples of ArchitectureBSP Application with Controllers and ViewsBSP Application with Several Views per ControllerCombination of the Previous ExamplesCalling Controllers of Other ApplicationsCalling Several Controllers from a ViewModel View Controller TutorialCreating ControllersCreating ViewsCalling ControllersDefining Your Own BSP ExtensionBSP Extension FrameworkCreating BSP ExtensionsDefining BSP ElementsDefining the Element ContentUser-Defined ValidationIteration Through Element ContentManipulation of the Element ContentPass by Reference for AttributesActivating the BSP ExtensionImplementing Element Handler ClassesGenerated Classes and Class HierarchyBasis Class CL_BSP_ELEMENTEntering DocumentationUsing BSP ElementsExample: Using Extensions in BSP PagesImplementing External Tools with WebDAVImplementing the Page Layout Using External ToolsMass Import for MIMEs Using WebDAVTips & TricksCopying Page AttributesMass Import for MIMEs Using WebDAVMIME RepositorySupported MIME TypesImporting MIME ObjectsUploading and Downloading MIME ObjectsCreating FoldersCreating Namespace FoldersConverting MIME Objects into BSPsClassifying MIME Objects as Relevant for TranslationAdditional FunctionsClassification ToolsetBasic ConceptsThe Nature of CharacteristicsMaintaining Object Type GroupsObject Types and Object Type GroupsObject FiltersWorking With Object Type GroupsMaintaining CharacteristicsWorking with CharacteristicsProperties of a CharacteristicAssigning Values to a CharacteristicSetting Default CharacteristicsMaintaining ClassificationsSelection Criteria in the Classification BrowserTree BrowserList BrowserClassifying Objects in the List BrowserClassification of Objects in the Classification GridClassifying Single ObjectsClassifying Multiple ObjectsCreating Object LinksRunning QueriesDefining Conditions for a Classification ReportExecuting a Report RunChecking the Results of a Report RunCreating and Configuring Service Providers and Service ConsumersProviding a Web ServiceDeveloping a Web Service in Outside-In ModeDeveloping a Web Service in Inside-Out ModeCreating a Service DefinitionEditing a Service DefinitionChanging the Service Definition ConfigurationConfiguring the Web Service RuntimeConfiguring Web Services and Web Service Clients in the SAP NetWConceptsConfiguration of Individual Web Services and Web Service ClientsConfiguration of Groups of Web ServicesConfiguration of Several Web Service ClientsService MeteringConfiguring Web ServicesConfiguring Individual Web ServicesConfiguring Groups of Web ServicesPreparing the Configuration Settings in ProfilesGrouping and Configuring Web Services in Configuration ScenariosEditing Configuration ScenariosManaging WSDL DocumentsAccessing Information Provided via WSILConfiguring Web Service ClientsConfiguring Individual Web Service ClientsCreating Web Service Physical DestinationsTesting Web Services in the Web Services NavigatorFinding Web ServicesTesting a Web Service OperationTesting Web Services with Pre-Defined Input DataViewing Web Services Logs and TracesConfiguring Proxy SettingsWorking with the SOA ManagerGlossary of Terms for SOA ManagerTechnical ConfigurationSetting Up the SOA ManagerChecking RolesRoles and AuthorizationsMigrating Web Service ConfigurationsWhat Migration DoesConfiguring Reverse ProxiesSetting Up a Connection to a J2EE Server for the Web Services NaConfiguring Service Providers and ConsumersConfiguring a Service ProviderConfiguring a Service Provider (Simplified)Configuring Multiple Service ProvidersCreating a Configuration ScenarioCreating and Editing a Configuration ProfileSwitching Configuration Profile VersionsConfiguring a Central Business ScenarioDefining Systems as Central SystemsCreating a Domain in a Central SystemCreating and Assigning Logon Data in a Central SystemCreating a Central Business ScenarioDistributing Changes from the Central System to Domain SystemsThe Central Design Time CacheCreating a Management Connection to the Central SystemConfiguring a Consumer ProxyConfiguring an Event ProviderWorking with Service GroupsCreating Routing Rules for Service GroupsLogical Receiver DeterminationTechnical Receiver Determination APITechnical Receiver Determination API: Coding ExamplesCreating a Fallback ConfigurationUsing Configuration TemplatesPublishing ServicesSetting Up the Connection to the Services RegistryFinding Information in the Services RegistryPublishing Service Endpoints AutomaticallyPublishing Individual Service DefinitionsCreating and Changing Publication Rules in the Back-end SystemAccessing and Testing a ServiceTesting a ServiceDisplaying a WSDL DocumentLogs and TracesDisplaying Logs and TracesConfiguring LogsConfiguring TracingSearching with Trace PatternsEvaluating SOA Configuration and Publication LogsActivating and Forwarding SOA Configuration TracesMonitoring SequencesGeneral Information on SequencesChoosing Selection CriteriaChecking the Sequence OverviewAnalyzing a SequenceEnding/Restarting/Debugging SequencesConsuming a Web ServiceGenerating a Consumer ProxyConsuming a Stateless Web ServiceConsuming a Stateless Web Service (XI 3.0 Compatible)Sending a MessageImplementing a Provider ProxyTroubleshootingFault MessagesReporting and Handling ErrorsProtocolsQuerying the PayloadActivating Extended XML HandlingAccessing the Message IDRuntime ConfigurationConsuming a Stateful Web ServiceConsuming a TU&C/C Web ServiceProtocolsTypes of Message TransmissionWeb Services Reliable MessagingProgramming with SequencesExactly-Once-in-Order in an LUWExactly-Once-in-Order in Multiple LUWsUsing Sequences in Other ModulesCreating a Persistent Sequence Without ProxyProgramming with Sequences at the Provider SideMaking a Web Service SecureTransport Security for Web Services (AS ABAP)Authentication for Web Services (AS ABAP)AuthorizationsRuntime Configuration with the SOA ManagerPublishing a Web ServiceClassifying ServicesPublishing Services with Transaction WSPUBLISHManaging the Web Service RuntimeConfiguring the Web Service RuntimeConfiguration in Single StepsCreating a Service DestinationPerforming Settings for bgRFCChecking the ConfigurationTroubleshooting in the Web Service RuntimeManaging the Event HandlerMonitoring the Web Service RuntimeWeb Service Runtime MonitorViewing Web Services Logs and TracesMonitoring SequencesMonitoring Sequences in the SOA ManagerGeneral Information on SequencesChoosing Selection CriteriaAnalyzing a SequenceEnding/Restarting/Debugging SequencesMonitoring MessagesMonitoring Event-Controlled ProcessingDebugging bgRFC UnitsTroubleshooting Using Monitoring ToolsSupported StandardsProceduresService Enabling with SAP NetWeaver Process IntegrationDesigning a ServiceDesigning a Data TypeDesigning a Message TypeDesigning a Service Interface and its OperationsImplementing a ServiceGenerating a Provider Proxy for the Service Interface (Inbound)Implementing the Proxy Source CodeConfiguring a Service ProviderConfiguring a Service Provider Using SAP NetWeaver AdministratorConfiguring a Service Provider Using the Integration DirectoryConfiguring a Service Provider Using SOA ManagerPublishing a ServiceConfiguring the Connection to the Services RegistryPublishing a Service to the Services RegistryChecking That the Service is AvailableConsuming a ServiceGenerating a Consumer ProxyConfiguring a Consumer ProxyConfiguring a Consumer Proxy Using SAP NetWeaver AdministratorConfiguring a Service Consumer Using SOA ManagerImplementing a Simple Consumer ApplicationWeb Application Builder for ITS ServicesIntroductionUser Settings for Internet ServicesBasic FunctionsCreating an Internet ServiceComponents of Internet ServicesUsing Mixed ModeCreating HTML TemplatesGeneration Style: ClassicGeneration Style: HTML BusinessGeneration Style: WebGUIExtending HTML TemplatesCreating MIME ObjectsCreating Non-Language-Specific MIME ObjectsCreating Language-Specific MIME ObjectsEditing MIME ObjectsCreating Language ResourcesPublishing a ServiceStatuses of Web Development ObjectsExecuting ServicesTools Used for Implementation SupportNavigating Using Double-ClickUsing Patterns and WizardsMiniApp MaintenanceCreating MiniApp ObjectsMaintaining Entries for MiniAppsITS Architecture ComponentsMaintaining Text ElementsCreating and Maintaining Text ElementsCreating List and Column HeadingsMaintaining Selection TextsMaintaining Text SymbolsAnalyzing Text ElementsAnalyzing Selection TextsAnalyzing Text SymbolsCopying Text ElementsTranslating Text ElementsMaintenance of MessagesCreating a Message ClassAdding a MessageCreating Long Texts for MessagesAssigning IMG Activities to a MessageMaintaining TransactionsDialog TransactionsReport TransactionsOO TransactionsVariant TransactionsParameter TransactionsVariant MaintenanceCreating and Maintaining VariantsCalling the Initial ScreenDisplaying a List of all VariantsCreating VariantsMaintaining the Attributes of a VariantChanging VariantsDeleting VariantsPrinting a VariantVariant AttributesVariable Values in VariantsAssigning a Date Calculation VariableUser-Specific Selection VariablesCreating User-Specific VariablesChanging Values InteractivelyChanging Values from a ProgramFixed Values from Table TVARVCCreating Table Variables from TVARVCExecuting Programs with VariantsDebuggerRuntime AnalysisInformation on Development ObjectsNavigation and Information System: OverviewThe Repository Information SystemEnvironment AnalysisDetermining the EnvironmentWhere-used ListsThe Application HierarchyThe Data BrowserCustomizing the Data Browser DisplayOther Data Browser FunctionsAdditional ConceptsInactive SourcesConceptSupport in the ABAP Workbench ToolsActivating an ObjectOverview of Inactive ObjectsStatus DisplayActivating Classes and InterfacesEffect of Inactive Sources on OperationsFurther EffectsInactive Sources and ModificationsClassic BAdIs
Package BuilderABAP Analysis ToolsDebuggerNew DebuggerStarting and Stopping the New DebuggerManaging SessionsUser Interface LayoutCustomizing the Work AreaSource Code Execution and NavigationBreakpointsWorking with Static BreakpointsWorking with Dynamic Breakpoints in the ABAP EditorWorking with Dynamic Breakpoints in the New DebuggerWorking with WatchpointsToolsStandard ToolsSource Code (Edit Control)Call StackVariable Fast DisplayBreakpointsSource CodeData ObjectsObject DisplayTypes of Object DisplaysTable DisplayStructure DisplaySingle Field DisplayData ExplorerSpecial ToolsDebugger Scripting ToolCreating and Executing a ScriptDebugger TracingCreating a Trace FileSAS: ABAP Debugger Tracing and ScriptingThe Local Debugger Script ClassSyntax of the Local Debugger Script ClassWeb Dynpro ToolLoaded Programs (Global Data)Memory AnalysisScreen AnalysisThe DiffToolSystem AreasConsole: XML and List Preview ToolNaming Conventions for Anonymous Storage ObjectsOther FunctionsSettingsSoftware Layer Aware DebuggingObject Sets in SLADDebugger ProfilesCreating a Persistent Object SetCreating a Persistent Debugger ProfileUsing a Profile in the ABAP DebuggerSimple Transformation DebuggerClassic DebuggerStarting and Stopping the Classic DebuggerSession ManagementUser InterfaceSource Code Execution and NavigationBreakpointsWorking with Single BreakpointsWorking with Multiple BreakpointsBreakpoints DisplayWorking with WatchpointsMemory Monitoring with WatchpointsData Object DisplayFields DisplayTable DisplayObject DisplayOther FunctionsSettingsMemory ConsumptionActivatable CheckpointsCheckpoint GroupsActivation SettingsLog DisplayActivation VariantsDefinition SettingsGroup OverviewRuntime AnalysisMeasurable ComponentsCreating MeasurementsSetting the Measurement AccuracyVariant DefinitionsExecuting MeasurementsPerformance ResultsMeasurement Display ToolAdapting Message DisplayHit ListsDatabase TablesProfilesProcessing BlocksCall HierarchyTimesComparison ToolsHit List ComparisonHit List Comparison ResultsIndividual LinesEvent HierarchyProgram Hit ListsHierarchy ComparisonCall Hierarchy Comparison ResultsTips and TricksPerformance AnalysisPerformance Trace OverviewArchitecture and NavigationInitial ScreenRecording Performance DataStarting the TraceStopping the TraceAnalyzing Performance DataDisplay FilterOther FiltersDisplaying Lists of Trace RecordsAnalyzing Trace RecordsSQL Trace AnalysisEmbedded SQLMeasured Database OperationsLogical Sequence of Database OperationsBufferingAnalyzing a Sample SQL Data FileExample Explanation of an Oracle StatementExample Explanation of an Informix StatementEnqueue Trace AnalysisEnqueue Trace RecordsDetailed Display of Enqueue Trace RecordsRFC Trace AnalysisRFC Trace RecordsDetailed Display of RFC Trace RecordsTable Buffer Trace AnalysisTable Buffer Trace RecordsDetailed Display of the Table Buffer Trace RecordsAdditional FunctionsSaving Lists LocallyThe Function Execute Explain for SQL StatementsUsing the Dictionary Information FunctionSummarizing Trace ListsCoverage AnalyzerCoverage and Program ModificationAdministrationCoverage Analyzer StatusTest Groups and RegistrationCreating a Test GroupReset Coverage ResultsSettingsMonitorConsistency ChecksGlobal DisplayDetail DisplayDisplay of Coverage ResultsProcessing Blocks and Source Code DisplayRuntime MonitorTest MaintenanceCreating and Activating TestsDisplaying, Changing, and Deleting TestsCollected Log RecordsAdministrationTest OverviewServer StatusLog RecordsLog BookSettingsMemory InspectorMemory SnapshotsList of Memory SnapshotsNavigationMemory Objects DisplayDisplay LayoutMemory Snapshots ComparisonCode InspectorInspectionCreating and Executing Persistent InspectionsCreating and Executing Anonymous InspectionsObject SetCreating and Processing Object SetsCheck VariantCreating and Processing Check VariantsABAP UnitAdvantages of Using ABAP UnitImplementation of ABAP Unit TestsTest ClassesTest AttributesTest MethodsMethods of the CL_AUNIT_ASSERT ClassFixturesProduction Code and Test CodeExampleExecution of ABAP Unit TestsResults DisplayWorkbench IntegrationUsing the Test Class Code WizardABAP Unit BrowserUsing the FavoritesUsing the Tag AssistantABAP Dump AnalysisABAP DictionaryTablesTable FieldsReference Fields and Reference TablesIncludesNamed IncludesForeign KeysGeneric and Constant Foreign KeysText TablesSemantic Attributes of Foreign KeysCardinalityType of Foreign Key FieldsMulti-Structured Foreign KeysTechnical SettingsData ClassSize CategoryBuffering PermissionBuffering TypesFull BufferingGeneric BufferingSingle-Record BufferingLoggingConverting Pooled Tables into Transparent TablesDatabase Table BuffersLocal Buffer SynchronizationExample of Buffer SynchronizationRestrictions and Recommendations for Table BufferingAccesses Proceeding Directly to the DatabaseTechnical Implementation of the Table BufferAnalyzing Buffer QualityIndexesSpecial Features of Secondary IndexesExtension IndexChecking Index UsageUnique IndexesIndex IdentifiersCustomizing IncludesAppend StructuresCreating TablesCreating Tables and Table FieldsCreating Foreign KeysMaintaining Technical SettingsCreating Secondary IndexesCreating an Extension IndexDelivery ClassActivation TypeError Message in the Foreign Key CheckMaking Changes to TablesAdding an Append StructureInserting an IncludeInserting New FieldsInitial ValuesDeleting an Existing FieldChanging Data Types and Lengths of Existing FieldsChanging the Table CategoryMoving FieldsCopying Fields from Another TableCopying Fields from an Entity TypeDeleting TablesViewsJoin, Projection and SelectionInner Join and Outer JoinForeign Key Relationship and Join ConditionMaintenance StatusTime-Dependent Key ComponentsInserts with Database ViewsDatabase ViewsIncludes in Database ViewsTechnical Settings of a Database ViewAppend ViewsProjection ViewsHelp ViewsMaintenance ViewsRestrictions for Maintenance and Help ViewsCreating ViewsCreating a Database ViewCreating Help ViewsCreating Projection ViewsCreating Maintenance ViewsMaintenance Attribute of a View FieldDelivery Class of a Maintenance ViewMaintaining Selection Conditions of ViewsCreating an Append ViewDeleting ViewsExample of ViewsTypesData ElementsCreating Data ElementsDocumentation and Documentation StatusField LabelsStructuresCreating StructuresNamed IncludesTable TypesCreating Table TypesKey Definition of a Table TypeAccess ModeKey CategorySecondary Keys for Table TypesGeneric Table TypesRanges Table TypesCreating a Ranges Table TypeDeleting TypesReference TypeDomainsFixed ValuesCreating Fixed Value AppendsValue TableInput and Output ConversionsCreating DomainsOutput StylesChanging DomainsDeleting DomainsSearch HelpsElementary Search HelpCollective Search HelpAppend Search HelpsAssignment of Search Helps to Screen FieldsAssignment of a Search Help to a Data ElementAssignment of a Search Help to a Check TableAssignment of a Search Help to a Table Field or Structure FieldDirect Assignment of a Search Help to a Screen FieldHierarchy of Search Help CallsValue Transport for Input HelpsCreating Elementary Search HelpsDialog TypesHot KeysDefault Values for Search Help ParametersCreating Collective Search HelpsCreating an Append Search HelpSearch Help ExitExample of Search HelpsLock ObjectsLock ModeFunction Modules for Lock RequestsConditions Required of Foreign KeysLock MechanismLocal Lock ContainersCreating Lock ObjectsDeleting Lock ObjectsExample of Lock ObjectsAdjustment of Database StructuresExample of ConversionConversion ProblemsContinuing Terminated ConversionsFinding Terminated ConversionsActivationRuntime ObjectsMass ActivationActivating Objects in the BackgroundData Types in the ABAP DictionaryPredefined ABAP TypesMapping of the ABAP Data TypesThe Database UtilityFunctions for Editing Tables and Indexes in the DatabaseFunctions for Editing Views in the DatabaseFunctions for Editing Pools and Clusters in the DatabaseProcessing TypesStorage ParametersDisplaying and Maintaining the Storage ParametersDisplaying Requests for Mass ProcessingScheduling Jobs for Mass ProcessingDisplaying Logs for Mass ProcessingDisplaying Temporary Tables without Restart LogsPooled and Cluster TablesCreating Table Pools/Table ClustersDeleting Table Pools/Table ClustersCreating Pooled Tables/Cluster TablesChanging Pooled and Cluster TablesFlight ModelSwitch FrameworkComponents and ArchitectureBusiness Function SetBusiness FunctionSwitchSwitch StatesConflicts and Conflict SwitchesSwitchable UnitsSwitch BC SetsActivating Switch BC SetsMaintenance TransactionsCreating SwitchesCreating Business FunctionsCreating Business Function SetsSwitching on Business FunctionsMaintaining Information About Business FunctionsABAP Programming InterfacesWriting RFC Programs in ABAPCalling RFC Function Modules in ABAPIntroductionRFC CallsParameters in Remote CallsCalling Remote Functions LocallyCalling Remote Functions BackRFC Call RestrictionsThings to Look Out for in UnicodeRFC ExceptionsUsing Pre-Defined Exceptions for RFCExceptions That Cannot Be HandledRFC VariantsSynchronous RFC (sRFC)Asynchronous RFC (aRFC)Call Properties of Asynchronous RFCsReceiving Results from an Asynchronous RFCKeeping Remote ContextsParallel Processing with Asynchronous RFCCALL FUNCTION - STARTING NEW TASKRECEIVEWAIT UNTILaRFC Programming ExampleTransactional RFC (tRFC)CALL FUNCTION - IN BACKGROUND TASKQueued RFC (qRFC)Writing Remote Function Modules in ABAPSteps for Implementing Remote Function ModulesProgramming TipsDebugging Remote Function ModulesSAP XSLT Processor ReferenceStatementsCreating the Result TreeFlow ControlDefining and Calling Template RulesStylesheets and StructuringTop-Level Help StatementsOutputAdditional SAP Statementssap:call-externalsap:external-functionsap:functionFunctionsXPath FunctionsXSLT FunctionsAdditional SAP FunctionsPreprocessor SequencesGeneral ConstraintsSimple TransformationsST – OverviewST Program StructureRoot ElementType DefinitionsData DeclarationsData RootsParameterVariablesMain TemplateExampleAddressing ABAP Data in Simple TransformationsTree Structure of the Data NodesCurrent NodeAddressing Data NodesAddressing the Data RootsAddressing the Current NodeAddressing SubnodesSerialization and DeserializationLiteral Template ContentLiteral XML Elements and AttributesControlling the Name Comparison of Literal XML ElementsControlling the Extensibility of Literal XML ElementsLiteral TextNon-Literal AttributesNamespacesTransformation of ABAP ValuesElementary Data ObjectsMapping RulesMapping ListLengthStructuresInternal TablesData Objects and All Their ComponentsAssigning ValuesAssigning a ValueDowncasting Reference VariablesInitializationTransformation of VariablesWriting Variables to XMLReading an XML Value into a VariableFlow ControlDefining the Transformation DirectionSkipping XML Elements During DeserializationConditional TransformationsPreconditionsAssertionsConditionsPatternsEmpty Template ContentSpecifying Data Nodes in ConditionsCase DistinctionGroupingProcess Control with VariablesConditions for VariablesCase Distinctions for VariablesSymmetry of Serialization and DeserializationModularization with SubtemplatesDefining SubtemplatesCalling SubtemplatesUsing Other ST ProgramsCalling TransformationsIncluding TransformationsAccess to ABAP Objects from ST ProgramsCalling Static MethodsCalling Instance MethodsCreating an ObjectST – AppendixRepresenting ABAP Values in STST – Overview of CommandsXML- LibraryPackage DOMInterface if_ixml_att_list_declInterface if_ixml_attributeInterface if_ixml_attribute_declInterface if_ixml_cdata_sectionInterface if_ixml_character_dataInterface if_ixml_commentInterface if_ixml_cond_dtd_sectionInterface if_ixml_content_particleInterface if_ixml_documentInterface if_ixml_document_fragmentInterface if_ixml_document_typeInterface if_ixml_elementInterface if_ixml_element_declInterface if_ixml_entity_declInterface if_ixml_entity_refInterface if_ixml_named_node_mapInterface if_ixml_namespace_contextInterface if_ixml_namespace_declInterface if_ixml_nodeInterface if_ixml_node_collectionInterface if_ixml_node_filterInterface if_ixml_node_filter_combiningInterface if_ixml_node_iteratorInterface if_ixml_node_listInterface if_ixml_notation_declInterface if_ixml_piInterface if_ixml_pi_parsedInterface if_ixml_pi_unparsedInterface if_ixml_textPackage EncodingInterface if_ixml_encodingPackage EventInterface if_ixml_eventPackage iXMLInterface if_ixmlPackage ParserInterface if_ixml_parse_errorInterface if_ixml_parserPackage RendererInterface if_ixml_rendererPackage StreamInterface if_ixml_istreamInterface if_ixml_ostreamInterface if_ixml_streamInterface if_ixml_stream_factoryPackage UnknownInterface if_ixml_unknowniXML ABAP Objects JumpstartThings you should know in advanceA sample XML documentWhat services does iXML provideWhat programming languages does iXML supportWhat operating platforms does iXML supportEnabling the iXML libraryBasic steps in your programParsing an XML document DOM-basedParsing an XML document event-basedCasting up and down the inheritance hierarchyCreating a DOM tree from scratchTraversing the DOM treeTraversing the DOM tree with iteratorsTraversing the DOM tree with filtersRendering a DOM tree into an XML documentABAP as OLE automation controllerIntroductionRegistering External Applications in an ABAP SystemLoading OLE Type Information into an ABAP System for ConversionConversion RulesUsing The OLE Object BrowserImplementationExamplesRelated ABAP keywordsCREATE OBJECTSET PROPERTYGET PROPERTYCALL METHODFREE OBJECTBC - ABAP und JavaScriptThe Class CL_JAVA_SCRIPTUsing the CL_JAVA_SCRIPT ClassStatic Methods of the CL_JAVA_SCRIPT ClassCREATEInstance Methods of the CL_JAVA_SCRIPT ClassABAP_DESTRUCTORBINDLink to ABAP Types I and FBinding to ABAP-Types DECFLOAT and PBinding to ABAP StructuresBinding to Internal TablesBinding to Data ReferencesBinding to Object References (Instances)Binding to Static Class ComponentsBIND_INSTANCECOMPILEDESTROYEVALUATEEXECUTEGETSETSET_BREAKPOINTCLEAR_BREAKPOINTCLEAR_BREAKPOINTSCLEAR_SCRIPT_BREAKPOINTSSTEPSTEP_INTOSTEP_OUTCONTINUEGET_CALL_STACKEVALUATE_IN_STACKStatic Attributes of the CL_JAVA_SCRIPT ClassConstantsInstance Attributes of the CL_JAVA_SCRIPT ClassLAST_CONDITION_CODELAST_ERROR_MESSAGEBREAKPOINT_SCRIPT_NAMEBREAKPOINT_LINE_NUMBERABAP Customer DevelopmentEnhancement FrameworkEnhancement ConceptEnhancement SpotsEnhancement OptionsEnhancement ImplementationsEnhancement TechnologiesABAP Source Code EnhancementsImplicit Enhancement Options in ABAP Source CodeExplicit Enhancement Options in ABAP Source CodeCreating Source Code Plug-InsFunction Module EnhancementsEnhancing Parameter InterfacesEnhancements to Classes and InterfacesEnhancing the Components of Classes or InterfacesBusiness Add-Ins (BAdIs)BAdI ConceptArchitectureDefinition of BAdIsInstance Generation ModeThe Multiple Use PropertyFunction Code and Screen EnhancementsBAdIs Embedded in the Enhancement FrameworkThe Problem with Large BAdI InterfacesEnhancement Spots and Enhancement ImplementationBAdIs – a Typical Use CaseBAdI Use CasesSingle-Use BAdIMultiple-Use BAdIRegistry PatternStep-By-Step Examples with BAdIsBuilding Your First BAdIHow to Implement a BAdIHow to Use FiltersMigrating Classic BAdIsDifferences Between Classic and New BAdIsMigrating BAdIsAdditional InformationDocumentationTips and TricksFAQsWorking with EnhancementsEnhancement BuilderCreating, Editing, and Deleting Enhancement SpotsCreating, Editing, and Deleting Enhancement ImplementationsEnhancement Information SystemDisplay OptionsAdjusting Enhanced ObjectsObjects Requiring AdjustmentCases When ABAP Source Code Needs AdjustmentCases When Function Modules Need AdjustmentCases When Classes and Interfaces Need AdjustmentCases When BadIs Need AdjustmentPerforming AdjustmentsAdjusting BAdI ImplementationsAdjusting Classes, Interfaces, Web Dynpros and Function GroupsAdjusting Source Code Plug-insAdjustment StatusChanging the SAP Standard (BC)PersonalizationPersonalizing an ApplicationHiding Screen ElementsHiding ScreensMoving Screen ElementsDefining Default Values for Input FieldsDisabling the Ready-For-Input Status of ElementsAdjusting Table ControlsAdjusting Tab PagesSimplifying Selection ScreensPersonalizing the Possible Entries HelpChanging Field TextsIncluding Graphics and TextInserting Pushbuttons for Frequently-Used FunctionsChanging Possible Entries into Radio ButtonsSimplifying Screens for Specific UsersTools for Personalizing the ApplicationTransaction Variants and Screen VariantsVariant TransactionsVariant GroupsGuiXTEnhancementsModification AssistantApplication-Specific User ExitsApplication-Specific Field SelectionSET/GET ParametersParameter TransactionsCreating a Parameter TransactionSelection VariantsTransaction Variants and Screen VariantsTransaction VariantsMaintenancePrerequisitesDialog BoxAdditional FeaturesStarting Transaction VariantsScreen VariantsCreating Screen VariantsAdditional FeaturesCalling Screen VariantsCreating and Maintaining Variant GroupsCreating Variant Groups and Assigning UsersMaintaining Variant Groups and Associated Transaction VariantsSwitching Between Variant GroupsOrder of Precedence for the Variant Values to Be DisplayedUser Authorizations for Variant GroupsTransportTable Control Layout in VariantsTransaction Variants and Screen Variants: RestrictionsTransaction Variants and Screen Variants: Special FeaturesGuiXT in Transaction Variants and Screen VariantsAdjusting Transactions Using GuiXTSimplifying NavigationEnhancements to the StandardEnhancement FrameworkClassic TechniquesClassic BAdIsArchitecture of Classic BAdIsComparison of Classic BAdIs with Previous TechniquesDefinition of a Classic BAdIDefining a Business Add-In in the Enterprise CoreCalling a Classic BAdIImplementing a Classic BAdIImplementing Methods of Classic BAdIsFilter-Dependent Classic BAdIsCall Sequence for Implementations Using Filter MechanismsClassic Multiple-Use BAdIsMenu EnhancementsScreen EnhancementsDefining Screen EnhancementsImplementing Screen EnhancementsSorting Classic BAdI ImplementationsProcedure for Importing Classic BAdIsCustomer ExitsEnhancements to the SAP Standard with Customer ExitsTypes of ExitsLocating Applications that Have ExitsCreating an Add-On ProjectActivating and Deactivating a ProjectTransporting Add-on ProjectsCreating Customer-Specific MenusCreating Customer-Specific SubscreensCreating Customer-Specific Function ModulesCreating Customer-specific DocumentationEnhancing IMGsModifying the StandardThe Modification AssistantGeneral Development OrganizationRecommendations for Modifying the SAP StandardOptimizing PerformanceCustomer DevelopmentUpgrade Procedure / Support PackagesAdjusting ABAP Dictionary ObjectsPrerequisitesProcess FlowPreparing to Run Transaction SPDDTransaction SPDDAdjusting Repository ObjectsPreparing to Run Transaction SPAUSelection Screen of Transaction SPAUTransaction SPAU: General FunctionsStatus of the Repository ObjectsReset to OriginalSpecial Features of Complete ObjectsAdjustment Category: With Modification AssistantAdjusting ProgramsAdjusting Classes and InterfacesAdjustments in the Screen PainterAdjustments in the Menu PainterAdjusting Text ElementsAdjusting Function ModulesAdjusting DocumentationAdjusting Role MenusAdjustment Category: Without Modification AssistantVersion ManagementDisplaying and Using VersionsFunctions in the Version OverviewPractical Examples of Version ManagementUpgrading from Release 4.5A or LessModifications Made by Several Different PeopleAdjusting Other SAP SystemsUpgrading the Development SystemUpgrading the Production SystemHandling Change Requests During AdjustmentChoosing a Change Request for ModificationsLocal and Transportable Change RequestsReleasing Tasks at the End of Modification AdjustmentTransferring Adjustments to Other SAP SystemsNotes (Troubleshooting)The SAP Software Change Registration Procedure (SSCR)What Is Registered?When Are Objects Registered?How Do You Get a Key in the Service System?Registering a Development UserRegistering an ObjectDisplaying an OverviewHow Can Registration Take Place Without SAPNet Access?Who Can Use Registration?Integration Tests for ABAP ApplicationsTest WorkbencheCATT: extended Computer Aided Test Tool (BC-TWB-TST-ECA)CATT: Enhanced Mode (BC-CAT-TOL)CATT: Computer Aided Test Tool (BC-CAT-TOL)SAP Virtual Machine Container