FTI_TR_POSITIONS with LDB_PROCESS

Hello everybody
I am trying to get data ouf of the LDB FTI_TR_POSITIONS but all I get is a runtime error: LDB_SELECTIONS_NOT_ACCEPTED
what am I doing wrong?
DATA callback LIKE ldbcb OCCURS 0 WITH HEADER LINE.
    DATA seltab   LIKE rsparams OCCURS 0 WITH HEADER LINE.
    callback-ldbnode = 'POSITIONS'.
    callback-get = 'X'.
    callback-get_late = 'X'.
    callback-cb_prog = 'ZTVWPAN2_1'.
    callback-cb_form = 'CALLBACK_FORM'.
    APPEND callback.
MOVE: 'I'      TO seltab-sign,
          'EQ'     TO seltab-option,
          'S'      TO seltab-kind,
          'BUKRS' TO seltab-selname.
    seltab-low = so_bukrs+3.
    APPEND seltab.
MOVE: 'I'      TO seltab-sign,
          'EQ'     TO seltab-option,
          'S'      TO seltab-kind,
          'S_DATS' TO seltab-selname,
          pa_stdat     TO seltab-low.
    APPEND seltab.
CALL FUNCTION 'LDB_PROCESS'
      EXPORTING
        ldbname                           = 'FTI_TR_POSITIONS'
      TABLES
        callback                          = callback
        selections                        = seltab
*EXCEPTIONS
Thanks for any help!!
Best regards
Christophe

Hi,
Anyone has any idea ?
Thanks,
Francis

Similar Messages

LDB CMC with LDB_PROCESS FM ?

Dear All,
1. I'm calling the Function Module LDB_PROCESS in my Program.
2. I'm passing CMC LDB to the above FM.
3. I've built the Necessary params to pass onto the FM.
4. But my Form is not getting triggered.
Please let me know the reason !
Enclosed is the code :
Data: wa_mastb like mastb.
SELECT-OPTIONS: s_matnr for wa_mastb-matnr.
DATA: CALLBACK    TYPE TABLE OF LDBCB,
            CALLBACK_WA LIKE LINE OF CALLBACK.
DATA: gt_SELTAB TYPE TABLE OF RSPARAMS,
            gwa_SELTAB LIKE LINE OF gt_SELTAB.
CLEAR CALLBACK_WA.
CALLBACK_WA-LDBNODE     = 'MASTB'.
CALLBACK_WA-GET         = 'X'.
CALLBACK_WA-GET_LATE    = ' '.
CALLBACK_WA-CB_PROG     = SY-REPID.
CALLBACK_WA-CB_FORM     = 'CALL_MASTB'.
APPEND CALLBACK_WA TO CALLBACK.
gwa_SELTAB-KIND    = 'S'.
gwa_SELTAB-SELNAME = 'MATNR'.
Loop at s_matnr.
MOVE-CORRESPONDING s_matnr to gwa_SELTAB.
append gwa_SELTAB to gt_seltab.
endloop.
START-OF-SELECTION.
CALL FUNCTION 'LDB_PROCESS'
EXPORTING
    LDBNAME                           = 'CMC'
*   VARIANT                           =
*   EXPRESSIONS                       =
*   FIELD_SELECTION                   =
*   DYN_NODE_TYPES                    =
TABLES
    CALLBACK                          = CALLBACK
    SELECTIONS                        = gt_SELTAB.
IF SY-SUBRC <> 0.
Write:/ 'Error in the Call of the LDB FM'.
ENDIF.
end-of-SELECTION.
FORM CALL_MASTB USING PD_NODE LIKE LDBN-LDBNODE
                                              PD_WORKAREA like mastb
                                              PD_MODE     TYPE C
                                              PD_SELECTED TYPE C.
data: ls_mastb like mastb.
CASE PD_NODE.
    WHEN 'MASTB'.
      LS_mastb = PD_WORKAREA.
      write:/ ls_mastb-matnr, ls_mastb-werks.
ENDCASE.
ENDFORM.
Regards,
Deepu.K

Hi!
for CMC LDB you must add parameter:
PARAMETERS :
         datuv LIKE stko-datuv DEFAULT sy-datum.
and fill it
CLEAR gwa_seltab.
gwa_seltab-kind    = 'P'.
gwa_seltab-selname = 'DATUV'.
gwa_seltab-sign    = 'I'.
gwa_seltab-option = 'EQ'.
gwa_seltab-low = datuv .
APPEND gwa_seltab TO gt_seltab.

Problem with LDB_PROCESS .. Not working in Loop

Hi Experts,
I am using FM LDB_PROCESS for calling PNM LDB iteratively for some data in internal table.
For the first record it works well and give me corresponding node values.
But for other line items/records of internal table, it does n't give me any output , although some of these line items contain exactly the same data as contained in first record.
Kindly help.
Regards,
Vikas

Dear Raymond,
I tried debugging the FM but it is not stopping at the perform you mentioned.
Then I opted for CALL FUNCTION 'LDB_CALL_LDB_PROCESS' starting new task v_task_id.
If I don't use "starting new task v_task_id" it gives dump at the following part of   'LDB_CALL_LDB_PROCESS' , stating Result table incompatible.
CALL FUNCTION 'LDB_CALLBACK'
         DESTINATION 'BACK'
         TABLES
              CALLBACK_TAB   = G_CALLBACK
              RESULTS        = RESULTS
              LDBNODES       = I_LDBS.
But if I use CALL FUNCTION 'LDB_CALL_LDB_PROCESS' starting new task v_task_id then it does n't give me any results.
Kindly help.
Regards,
Vikas

Usage of LDB

I want to try a report where I can use LDB.So tried as follows
Report zgldb.
Nodes:pap.
When I just compile it says 'PAP is not a node of Logical database _S'..
what does this mean.How to use LDB in a report?
Thank you

Dear Gopi,
Logical Databases
Logical databases are special ABAP programs that retrieve data and make it available to application programs. The most common use of logical databases is still to read data from database tables by linking them to executable ABAP programs.
However, from Release 4.5A, it has also been possible to call logical databases using the function module LDB_PROCESS. This allows you to call several logical databases from any ABAP program, nested in any way. It is also possible to call a logical database more than once in a program, if it has been programmed to allow this. This is particularly useful for programs with type 1.
Logical databases contain Open SQL statements that read data from the database. You do not therefore need to use SQL in your own programs. The logical database reads the program, stores them in the program if necessary, and then passes them line by line to the application program or the function module LDB_PROCESS using an interface work area.
Logical Databases - Views of Data
A logical database provides a particular view of database tables in the R/3 System. It is always worth using logical databases if the structure of the data that you want to read corresponds to a view available through a logical database.
There are two ways of using a logical database: Either by linking it with an executable program, or by using the function module LDB_PROCESS in any ABAP program.
When you link a logical database to an executable program, the user can enter values on the selection screen, and the data read by the logical database is passed back to the program using the interface work areas. If you call the logical database using a function module, the selection screen is not displayed. The calling program does not have to provide interface work areas. Instead, it uses special subroutines called callback routines, which are called by the function module and filled with the required data.
Linking a Logical DB to an Executable Program
When you link an executable program to a logical database by entering the name of the logical database in the program attributes, the subroutines of the logical database program and the event blocks of the executable program form a modularized program for reading and processing data. The individual processing blocks are called in a predefined sequence by the runtime environment (see the diagram in the section Logical Databases and Contexts). The runtime sequence is controlled by the structure, selections, and PUT statements in the logical database, and by the GET statements in the executable program.
Selection Screen
If you specify a logical database in the attributes of an executable program, this affects the standard selection screen of the program. It contains both the selection fields from the logical database and those from the program itself. You can specify which of the logical database selections are relevant for your program, and should therefore appear on the screen, by declaring interface work areas for the relevant nodes.
Runtime Behavior
The following list shows the sequence in which the ABAP runtime environment calls the subroutines of the logical database and the event blocks in the executable program. The runtime environment executes a series of processors (selection screen processor, reporting processor). The ABAP code listed below shows the processing blocks that belong to the individual steps.
Initialization before the selection screen is processed.
Subroutine:
FORM INIT
This subroutine is called once only before the selection screen is first displayed.
Event block:
INITIALIZATION.
This event occurs once only before the selection screen is first displayed.
PBO of the Selection screen Initialization before each occasion on which the selection screen is displayed (for example, to supply default values for key fields).
Subroutine:
FORM PBO.
This subroutine is called each time the selection screen is sent (before it is displayed).
Event block:
AT SELECTION-SCREEN OUTPUT.
This event is called each time the selection screen is sent (before it is displayed).
The selection screen is displayed at the presentation server, and the user can enter data in the input fields.
Input help (F4) or field help (F1) requests.
Subroutines:
FORM <par>_VAL.
FORM <selop>_VAL.
FORM <selop>-LOW_VAL.
FORM <selop>-HIGH_VAL.
If the user requests a list of possible entries for database-specific parameters <par> or selection criteria <selop>, these subroutines are called as required.
If the user requests field help for these parameters, the subroutines are called with the ending _HLP instead of _VAL.
Event blocks:
AT SELECTION-SCREEN ON VALUE-REQUEST FOR <par>.
AT SELECTION-SCREEN ON VALUE-REQUEST FOR <selop>-LOW.
AT SELECTION-SCREEN ON VALUE-REQUEST FOR <selop>-HIGH.
If the user requests a list of possible entries for database-specific parameters <par> or selection criteria <selop>, these events are triggered as required.
If the user requests field help for these parameters, the events with the addition ON HELP-REQUEST occurs instead of ON VALUE-REQUEST.
PAI of the selection screen. Checks to see whether the user has entered correct, complete, and plausible data. Also contains authorization checks. If an error occurs, you can program a user dialog and make the relevant fields ready for input again.
Subroutines:
FORM PAI USING FNAME MARK.
The interface parameters FNAME and MARK are passed by the runtime environment.
FNAME contains the name of a selection criterion or parameter on the selection screen.
If MARK = SPACE, the user has entered a simple single value or range selection.
If MARK = '*', the user has also entered selections on the Multiple Selection screen.
Using the combination FNAME = '*' and MARK = 'ANY', you can check all entries at once when the user chooses a function or presses ENTER.
Event blocks:
AT SELECTION-SCREEN ON <fname>.
Event for processing a particular input field.
AT SELECTION-SCREEN ON END OF <fname>.
Event for processing multiple selections.
AT SELECTION-SCREEN.
Event for processing all user input.
Processing before reading data.
Subroutine:
BEFORE EVENT 'START-OF-SELECTION'.
The logical database can use this subroutine for necessary actions before reading data, for example, initializing internal tables.
Event block:
START-OF-SELECTION.
First event in an executable program after the selection screen has been processed. You can use this event block to prepare the program for processing data.
Reading data in the logical database and processing in the executable program.
Subroutine:
FORM PUT_<node>
The logical database reads the selected data of the node <node>.
Event block:
GET <table> [LATE].
This event is triggered by the PUT statement in the above subroutine. This event block allows you to process the data read for <node> in the corresponding interface work area.
Processing after reading data.
Subroutine:
AFTER EVENT 'END-OF-SELECTION'.
The logical database can use this subroutine for necessary actions after reading data, for example, releasing memory space.
Event block:
END-OF-SELECTION.
Last reporting event. You can use this event block to process the temporary dataset that you have created (for example, sort it).
If a list was generated during the above steps, the list processor in the runtime environment takes control of the program and displays the list.
Suppose TABLE1 is the root node and TABLE2 is its only subordinate node in a logical database. The processing steps for reading and processing data would then have the following hierarchical order:
START-OF-SELECTION.
FORM PUT_TABLE1.
GET TABLE1.
    FORM PUT_TABLE2.
    GET TABLE2.
GET TABLE1 LATE.
END-OF-SELECTION.
Authorization Checks in Logical Databases
It makes sense to use authorization checks using the AUTHORITY-CHECK statement in the following subroutines in the database program or event blocks of the executable program:
Subroutines in the database program:
- PAI
- AUTHORITY_CHECK_<table>
Event blocks in the executable program:
- AT SELECTION-SCREEN
- AT SELECTION-SCREEN ON <fname>
- AT SELECTION-SCREEN ON END OF <fname>
- GET <table>
Whether you place the authorization checks in the database program or in the executable program depends on the following:
The structure of the logical database.
For example, you should only check authorizations for company code if you actually read lines containing the company code at runtime.
Performance
Avoid repetitive checks (for example, within a SELECT loop).
The separation of database access and application logic allows you to program all of your authorization checks centrally in the logical database program. This makes it easier to maintain large programming systems.
Calling a Logical Database Using a Function Module
From Release 4.5A it is possible to call logical databases independently from any ABAP program. Previously it was only possible to link a logical database to an executable program, in which the processing blocks of the logical database and the program were controlled by the ABAP runtime environment.
To call a logical database from another program, use the function module LDB_PROCESS. This allows you to use the logical database as a routine for reading data. You can call more than one logical database from the same program. You may also call the same logical database more than once from the same program. In the past, it was only possible to use a logical database more than once or use more than one logical database by calling a further executable program using SUBMIT. These programs had to be linked to the corresponding logical database, and the data had to be passed to the calling program using ABAP memory or a similar technique.
When you call a logical database using the function module LDB_PROCESS, its selection screen is not displayed. Instead, you fill the selections using the interface parameters of the function module. The logical database does not trigger any GET events in the calling program, but passes the data back to the caller in callback routines. Calling a logical database using LDB_PROCESS thus decouples the actual data retrieval from the preceding selection screen processing and the subsequent data processing.
There is no need to adapt a logical database for use with LDB_PROCESS, except in the following cases: If you do not adapt a logical database, it is not possible to use the function module to call the same logical database more than once. The PAI subroutine is not called when you use LDB_PROCESS. This means that none of the checks for selections programmed in it are performed. You can work around these restrictions by including the subroutines LDB_PROCESS_INIT and LDB_PROCESS_CHECK_SELECTIONS in the database program.
Runtime Behavior
The subroutines in the logical database are called in the following sequence when you call the function module LDB_PROCESS:
LDB_PROCESS_INIT
INIT
LDB_PROCESS_CHECK_SELECTIONS
PUT <node>.
None of the subroutines used to process the selection screen when you link the logical database to an executable program are called, neither does the runtime environment trigger any reporting events in the calling program. Instead, the PUT statements in the logical database trigger actions in the function module that call callback routines in the calling program. In other words, the function module catches the events that are otherwise processed by the runtime environment.
Parameters of LDB_PROCESS
The function module has the following import parameters:
LDBNAME
Name of the logical database you want to call.
VARIANT
Name of a variant to fill the selection screen of the logical database. The variant must already be assigned to the database program of the logical database. The data is passed in the same way as when you use the WITH SELECTION-TABLE addition in a SUBMIT statement.
EXPRESSIONS
In this parameter, you can pass extra selections for the nodes of the logical database for which dynamic selections are allowed. The data type of the parameter RSDS_TEXPR is defined in the type group RSDS. The data is passed in the same way as when you use the WITH FREE SELECTION addition in a SUBMIT statement.
FIELD_SELECTION
You can use this parameter to pass a list of the required fields for the nodes of the logical database for which dynamic selections are allowed. The data type of the parameter is the deep internal table RSFS_FIELDS, defined in the type group RSFS. The component TABLENAME contains the name of the node and the deep component FIELDS contains the names of the fields that you want to read.
The function module has the following tables parameters:
CALLBACK
You use this parameter to assign callback routines to the names of nodes and events. The parameter determines the nodes of the logical database for which data is read, and when the data is passed back to the program and in which callback routine.
SELECTIONS
You can use this parameter to pass input values for the fields of the selection screen of the logical database. The data type of the parameter corresponds to the structure RSPARAMS in the ABAP Dictionary. The data is passed in the same way as when you use the WITH SELECTION-TABLE addition in a SUBMIT statement.
If you pass selections using more than one of the interface parameters, values passed in SELECTIONS and EXPRESSIONS overwrite values for the same field in VARIANT.
Read Depth and Callback Routines
When you link a logical database with an executable program, the GET statements determine the depth to which the logical database is read. When you call the function module LDB_PROCESS, you determine the depth by specifying a node name in the CALLBACK parameter. For each node for which you request data, a callback routine can be executed at two points. These correspond to the GET and GET LATE events in executable programs. In the table parameter CALLBACK, you specify the name of the callback routine and the required execution point for each node. A callback routine is a subroutine in the calling program or another program that is to be executed at the required point.
For the GET event, the callback routine is executed directly after the data has been read for the node, and before the subordinate nodes are processed. For the GET_LATE event, the callback routine is processed after the subordinate nodes have been processed.
The line type of the table parameter CALLBACK is the flat structure LDBCB from the ABAP Dictionary. It has the following components:
LDBNODE
Name of the node of the logical database to be read.
GET
A flag (contents X or SPACE), to call the corresponding callback routine at the GET event.
GET_LATE
A flag (contents X or SPACE), to call the corresponding callback routine at the GET LATE event.
CB_PROG
Name of the ABAP program in which the callback routine is defined.
CB_FORM
Name of the callback routine.
If you pass an internal table to the CALLBACK parameter, you must fill at least one of the GET or GET_LATE columns with X for each node (you may also fill both with X).
A callback routine is a subroutine that must be defined with the following parameter interface:
FORM <subr> USING <node> LIKE LDBCB-LDBNODE
                  <wa>   [TYPE <t>]
                  <evt>
                  <check>.
The parameters are filled by the function module LDB_PROCESS. They have the following meaning:
<node> contains the name of the node.
<wa> is the work area of the data read for the node. The program that calls the function module LDB_PROCESS and the program containing the callback routine do not have to declare interface work areas using NODES or TABLES. If the callback routine is only used for one node, you can use a TYPE reference to refer to the data type of the node in the ABAP Dictionary. Only then can you address the individual components of structured nodes directly in the subroutine. If you use the callback routine for more than one node, you cannot use a TYPE reference. In this case, you would have to address the components of structured nodes by assigning them one by one to a field symbol.
<evt> contains G or L, for GET or GET LATE respectively. This means that the subroutine can direct the program flow using the contents of <evt>.
<check> allows the callback routine to influence how the program is processed further (but only if <evt> contains the value G). The value X is assigned to the parameter when the subroutine is called. If it has the value SPACE when the subroutine ends, this flags that the subordinate nodes of the logical database should not be processed in the function module LDB_PROCESS. This is the same as leaving a GET event block using CHECK in an executable program. If this prevents unnecessary data from being read, it will improve the performance of your program.
Exceptions of LDB_PROCESS
LDB_ALREADY_RUNNING
A logical database may not be called if it is still processing a previous call. If this occurs, the exception LDB_ALREADY_RUNNING is triggered.
LDB_NOT_REENTRANT
A logical database may only be called repeatedly if its database program contains the subroutine LDB_PROCESS_INIT, otherwise, this exception is triggered.
LDB_SELECTIONS_NOT_ACCEPTED
Error handling in the subroutine LDB_PROCESS_CHECK_SELECTIONS of the database program can trigger this exception. The error message is placed in the usual system fields SY-MSG....
For details of further exceptions, refer to the function module documentation in the Function Builder.
Example
TABLES SPFLI.
SELECT-OPTIONS S_CARR FOR SPFLI-CARRID.
TYPE-POOLS: RSDS, RSFS.
DATA: CALLBACK TYPE TABLE OF LDBCB,
      CALLBACK_WA LIKE LINE OF CALLBACK.
DATA: SELTAB TYPE TABLE OF RSPARAMS,
      SELTAB_WA LIKE LINE OF SELTAB.
DATA: TEXPR TYPE RSDS_TEXPR,
      FSEL TYPE RSFS_FIELDS.
CALLBACK_WA-LDBNODE     = 'SPFLI'.
CALLBACK_WA-GET         = 'X'.
CALLBACK_WA-GET_LATE    = 'X'.
CALLBACK_WA-CB_PROG     = SY-REPID.
CALLBACK_WA-CB_FORM     = 'CALLBACK_SPFLI'.
APPEND CALLBACK_WA TO CALLBACK.
CLEAR CALLBACK_WA.
CALLBACK_WA-LDBNODE     = 'SFLIGHT'.
CALLBACK_WA-GET         = 'X'.
CALLBACK_WA-CB_PROG     = SY-REPID.
CALLBACK_WA-CB_FORM     = 'CALLBACK_SFLIGHT'.
APPEND CALLBACK_WA TO CALLBACK.
SELTAB_WA-KIND = 'S'.
SELTAB_WA-SELNAME = 'CARRID'.
LOOP AT S_CARR.
MOVE-CORRESPONDING S_CARR TO SELTAB_WA.
APPEND SELTAB_WA TO SELTAB.
ENDLOOP.
CALL FUNCTION 'LDB_PROCESS'
     EXPORTING
          LDBNAME                     = 'F1S'
          VARIANT                     = ' '
          EXPRESSIONS                 = TEXPR
          FIELD_SELECTION             = FSEL
     TABLES
          CALLBACK                    = CALLBACK
          SELECTIONS                  = SELTAB
     EXCEPTIONS
          LDB_NOT_REENTRANT           = 1
          LDB_INCORRECT               = 2
          LDB_ALREADY_RUNNING         = 3
          LDB_ERROR                   = 4
          LDB_SELECTIONS_ERROR        = 5
          LDB_SELECTIONS_NOT_ACCEPTED = 6
          VARIANT_NOT_EXISTENT        = 7
          VARIANT_OBSOLETE            = 8
          VARIANT_ERROR               = 9
          FREE_SELECTIONS_ERROR       = 10
          CALLBACK_NO_EVENT           = 11
          CALLBACK_NODE_DUPLICATE     = 12
          OTHERS                      = 13.
IF SY-SUBRC <> 0.
WRITE: 'Exception with SY-SUBRC', SY-SUBRC.
ENDIF.
FORM CALLBACK_SPFLI USING NAME TYPE LDBN-LDBNODE
                          WA    TYPE SPFLI
                          EVT   TYPE C
                          CHECK TYPE C.
CASE EVT.
   WHEN 'G'.
      WRITE: / WA-CARRID, WA-CONNID, WA-CITYFROM, WA-CITYTO.
      ULINE.
    WHEN 'L'.
      ULINE.
ENDCASE.
ENDFORM.
FORM CALLBACK_SFLIGHT USING NAME TYPE LDBN-LDBNODE
                            WA    TYPE SFLIGHT
                            EVT   TYPE C
                            CHECK TYPE C.
WRITE: / WA-FLDATE, WA-SEATSOCC, WA-SEATSMAX.
ENDFORM.
The data structure in a logical database is hierarchical. Many tables in the R/3 System are linked to each other using foreign key relationships. Some of these dependencies form tree-like hierarchical structures. Logical databases read data from database tables that are part of these structures.
Tasks of Logical Databases
As well as allowing you to read data from the database, logical databases also allow you to program other tasks centrally, making your application programs less complicated. They can be used for the following tasks:
Reading the same data for several programs.
The individual programs do not then need to know the exact structure of the relevant database tables (and especially not their foreign key relationships). Instead, they can rely on the logical database to read the database entries in the right order during the GET event.
Defining the same user interface for several programs.
Logical databases have a built-in selection screen. Therefore, all of the programs that use the logical database have the same user interface.
Central authorization checks
Authorization checks for central and sensitive data can be programmed centrally in the database to prevent them from being bypassed by simple application programs.
Improving performance
If you want to improve response times, logical databases permit you to take a number of measures to achieve this (for example, using joins instead of nested SELECT statements). These become immediately effective in all of the application programs concerned and save you from having to modify their source code.
A program-specific selection screen is defined at the beginning of the program. This requires the TABLES statement. Next, the required variables are defined for the interface.
The internal table CALLBACK is filled so that various callback routines are called in the program for the two nodes SPFLI and SFLIGHT. For SPFLI, the routine is to be called for GET and GET_LATE, for SFLIGHT, only at the GET event.
The internal table SELTAB is filled with values for the node SPFLI from the selection table S_CARR from the program-specific selection screen.
The program then calls the function module LDB_PROCESS with these parameters.
The subroutines CALLBACK_SPFLI and CALLBACK_SFLIGHT serve as callback routines. The interface parameter WA is fully typed, so you can address the individual components of the work areas. The events GET and GET LATE are handled differently in CALLBACK_SPFLI.
Regards,
Rajesh K Soman
<b>Please reward points if found helpful</b>

FM LDB_PROCESS with PNP or PNPCE does not work...

This is the code. This do nothing, no errors, no results.(The system have employees.)Please help with some advice.
José.
TABLES: PERNR.
TYPE-POOLS: RSDS, RSFS.
DATA: CALLBACK TYPE TABLE OF LDBCB,
      CALLBACK_WA LIKE LINE OF CALLBACK.
DATA: SELTAB TYPE TABLE OF RSPARAMS,
      SELTAB_WA LIKE LINE OF SELTAB.
DATA: TEXPR TYPE RSDS_TEXPR,
      FSEL TYPE RSFS_FIELDS.
Refresh: Callback.
Clear: Callback.
CALLBACK_WA-LDBNODE     = 'PERNR'.
CALLBACK_WA-GET         = 'X'.
*CALLBACK_WA-GET_LATE    = ' '.
CALLBACK_WA-CB_PROG     = SY-REPID.
CALLBACK_WA-CB_FORM     = 'PROG_PERNR'.
APPEND CALLBACK_WA TO CALLBACK.
Refresh: Seltab.
Clear: Seltab.
SELTAB_WA-SELNAME = 'PERNR'.
SELTAB_WA-SIGN    = 'I'.
SELTAB_WA-KIND    = 'P'.
SELTAB_WA-OPTION = 'EQ'.
CLEAR SELTAB_WA-LOW.
CLEAR SELTAB_WA-HIGH.
APPEND SELTAB_WA TO SELTAB.
Refresh: TEXPR, FSEL.
Clear: TEXPR, FSEL.
CALL FUNCTION 'LDB_PROCESS'
EXPORTING
    LDBNAME                     = 'PNP'
    EXPRESSIONS                 = TEXPR[]
    FIELD_SELECTION             = FSEL[]
TABLES
    CALLBACK                    = CALLBACK
    SELECTIONS                  = SELTAB
EXCEPTIONS
    LDB_NOT_REENTRANT           = 1
    LDB_INCORRECT               = 2
    LDB_ALREADY_RUNNING         = 3
    LDB_ERROR                   = 4
    LDB_SELECTIONS_ERROR        = 5
    LDB_SELECTIONS_NOT_ACCEPTED = 6
    VARIANT_NOT_EXISTENT        = 7
    VARIANT_OBSOLETE            = 8
    VARIANT_ERROR               = 9
    FREE_SELECTIONS_ERROR       = 10
    CALLBACK_NO_EVENT           = 11
    CALLBACK_NODE_DUPLICATE     = 12
    OTHERS                      = 13.
   case sy-subrc.
      when 1. raise ldb_not_reentrant.
      when 2. raise ldb_incorrect.
      when 3. raise ldb_already_running.
      when 4. raise ldb_error.
      when 5. raise ldb_selections_error.
      when 6. raise ldb_selections_not_accepted.
      when 7. raise variant_not_existent.
      when 8. raise variant_obsolete.
      when 9. raise variant_error.
      when 10. raise free_selections_error.
      when 11. raise callback_no_event.
      when 12. raise callback_node_duplicate.
    endcase.
if sy-subrc ne 0.
      message id sy-msgid type sy-msgty number sy-msgno
           with sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
endif.
*&      Form PROG_PERNR
*       text
*      -->NAME       text
*      -->WA         text
*      -->EVT        text
*      -->CHECK      text
FORM PROG_PERNR USING NAME TYPE LDBN-LDBNODE
                      WA    TYPE PERNR
                      EVT   TYPE C
                      CHECK TYPE C.
    message id sy-msgid type sy-msgty number sy-msgno
           with sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
CASE EVT.
    WHEN 'G'.
      WRITE: / WA-PERNR.
      ULINE.
    WHEN 'L'.
ENDCASE.
ENDFORM.                    "PROG_PERNR

Yes, this is the best way of fill out these tables. But my problem is different, I'm trying to get the infotypes info through a BADI or function module.
I received a response from SAP about how to resolve this issue. I need to use the old way:
SUBMIT...RETURN to call another report with the PNP/PNPCE Logical Database.
That's the reason for use the LDB_PROCESS function module. (SUBMIT...RETURN uses too many memory and processor resources) Now I know that this function module does not work with HR Logical Databases because the Infotypes structures.
Thank you by your quick reponse.
José

How to use LDB PNP with ABAP objects in a program

Hello,
I am wondering if anybody has used the HR logical database(LDB) PNP with user defined ABAP objects in a program? I am using the FM- <b>LDB_PROCESS</b> but its not working. Also assigning PNP in the attributes section of the program -- so that I can use predefined fields from the LDB and then invoking the FM doesn't work -- throwing 'Logical database already active' error.
I suppose even with the ABAP objects and the new FM -- I should still be able to utilize the pre-defined fields of the PNP database -- and also the built in authorizations. I cannot use GET PERNR and REJECT as they give errors. I understand that the use of HR-macros (RP-PROVIDE-FROM-LAST and et al.) are not allowed as they use the table work area -- which is not allowed in ABAP-OOPS.
I would really appreciate if anyone could show me some insight regarding this. Thank you.
Kshitij R. Devre

Hi Kshitij
It would be really good if we could use both together. But as I know, it is not possible. "GET pernr." is an event-like loop statement and so cannot be used in OO context. And I guess, the same restriction holds for the "LDB_PROCESS" since it uses LDB-specific processing.
What I suggest you is to use standard and BAPI functions.
Sorry for giving bad news...
*--Serdar

Define selection screen for ldb_process

Hi I'm using the call function ldb_process for KDF(lfa1, lfb1, bsik), the trouble is that the information its different than if i do it on a normal report defining the logical database kdf and selection screen 903.
I find that the difference is because the selection screen, this is because the default selection screen for the kdf database is 1000, and this selection has the "Open items at key date" selection with the current date.
The question is:
How can i define the selection screen 903 using the call function ldb_proces?
Thanks
Pablo Santos

Hi,
You cannot define screen version 903 using function LDB_PROCESS. Instead use table "SELECTIONS" of the function module .
Cheers.

Problem with logical database

Hello experts,
i want to mix the data of the two transactions CjI3 CjI5 into one table. Both Transactions or programs use LDB psj. So i want to use one perform for each LDB call. I want to call the LDB with the FM LDB_PROCESS.
I want to get the data of the actual project costs with the code below.
DATA: lt_callback TYPE TABLE OF ldbcb,
        ls_callback LIKE LINE OF lt_callback.
DATA: lt_seltab TYPE TABLE OF rsparams,
        ls_seltab LIKE LINE OF lt_seltab.
DATA: lt_select_fields   TYPE rsfs_fields.
CALL FUNCTION 'CJDB_FREE_MEMORY_LDB_PSJ'.
gd_kokrs = 'URNC'.
* init event
SET PARAMETER ID 'CAC' FIELD 'URNC'.
* define nodes for ldb call
ls_callback-ldbnode     = 'PROJ'.
ls_callback-get         = 'X'.
* ls_callback-get_late    = 'X'.
ls_callback-cb_prog     = sy-repid.
ls_callback-cb_form     = 'CALLBACK_PROJ_ACT'.
append ls_callback to lt_callback.
clear ls_callback.
ls_callback-ldbnode     = 'VBAP'.
ls_callback-get         = 'X'.
* ls_callback-get_late    = 'X'.
ls_callback-cb_prog     = sy-repid.
ls_callback-cb_form     = 'CALLBACK_VBAP_ACT'.
append ls_callback to lt_callback.
...defining the other callback forms
* set selcrit
CLEAR ls_seltab.
ls_seltab-SELNAME = 'CN_AKTDT'.
ls_seltab-KIND = 'P'.
ls_seltab-LOW = 'X'.
APPEND ls_seltab to lt_seltab.
CLEAR ls_seltab.
ls_seltab-SELNAME = 'CN_AMODI'.
ls_seltab-KIND = 'P'.
ls_seltab-LOW = 'X'.
APPEND ls_seltab to lt_seltab.
* other selcrits
* fill table for field selection
PERFORM f01_fill_select_fields TABLES lt_select_fields.
flg_no_stop_info = con_on.
* flg_psj_no_gen = con_on.
* cn_corep = con_on.
psj_handle_tcndb = 3000.
* set tcode (direct for batch processing)
gd_tcode = 'CJI3'.
* save repid for selection
gd_repid_save = sy-repid.
* set tcode (direct for batch processing)
gd_tcode = 'CJI3'.
* flag aus start of selection
*   flg_no_database = con_on.
* For DB Profiles
DATA: ls_tcndb TYPE tcndb,
      ls_tcnds TYPE tcnds.
Select SINGLE * from tcndb
into ls_tcndb
WHERE PROFID = 'URENCO_PS001'.
IF sy-subrc = 0.
   EXPORT CN_TCNDB FROM LS_TCNDB
      TO MEMORY ID 'SAPDBPSJ_CN_TCNDB'.
   TCNDB = LS_TCNDB.
ENDIF.
Select SINGLE * from tcnds
into ls_tcnds
WHERE DB_VIEW = '000000000001'.
IF sy-subrc = 0.
   EXPORT CN_TCNDS FROM LS_TCNDS
      TO MEMORY ID 'SAPDBPSJ_CN_TCNDB'.
   TCNDS = LS_TCNDS.
ENDIF.
psj_caller = sy-repid.
CALL FUNCTION 'LDB_PROCESS'
    EXPORTING
      LDBNAME                           = 'PSJ'
*     VARIANT                           =
*     EXPRESSIONS                       =
    FIELD_SELECTION                   = lt_select_fields
*     DYN_NODE_TYPES                    =
    TABLES
      CALLBACK                          = lt_callback
     SELECTIONS                        = lt_seltab
   EXCEPTIONS
     LDB_NOT_REENTRANT                 = 1
But only the project table is filled. But i also need the nodes
proj
vbap
PRPS_R
AUFK
ACT01
PSMERK
PSMERK_PRPS
PSMERK_ACT
But i didnt get some data in it. I don know why.
The table gt_proj is filled in the call back form. But not the other tables???
Can anybody help.
If you need more information say it.
Edited by: christopher Pollok on Jun 20, 2011 4:20 PM

Solved

Func Module : LDB_PROCESS and Logical Database ADA

Hi All,
How to get 'ANLB' data from logical database 'ADA' using the
function module 'LDB_PROCESS'?
Is there any other way to done this without getting into SELECTION SCREEN of this LOGICAL DATABASE?
With Thanls & Regards,
R.Nagarajan.
We can -

Hi,
Using LDB_PROCESS will made all the fields of this LDB available to you......this is the way ..you can use n number of LDB's in your program apart from the one that u mention in Program attributes....
for more details and Function call..use..
Re: How to hide the selection screen of a Logical datebase?

LDB_PROCESS selections problem

Hi there dear ABAP'ers.
I've got such a question
I've got a standard report F.05, which doesn't do BD SELECTs directly, but instead it calls LDB_PROCESS FModule and processes a 'SDF' LDBase.
    call function 'LDB_PROCESS'
       exporting
            ldbname                     = 'SDF'
*          VARIANT                     =
           EXPRESSIONS                 = sdf_expressions
*          FIELD_SELECTION             =
*          DYN_NODE_TYPES              =
       tables
            callback                    = gt_callback
           SELECTIONS                  = seltab
       exceptions
F.05 for G/L accounts valuation returns some 'aggregated' values, and I would like to debug it somehow.
When I debug the place in code where LDB_PROCESS is calleg, I see that FM's parameter 'SELECTIONS' contains an itab:
SELNAME KIND SIGN OPTION LOW
D_SAKNR|S   |I   |EQ    |3110000000
X_CURTP|S   |I   |EQ    |60
D_BUKRS|S   |I   |EQ    |TCLZ
D_GJAHR|S   |I   |EQ    |2009
I try to edit a 'SDF' LDbase in SE36 transaction. I am launching a SELECTIONS screen, then try to insert into screen fields values as in FModule's parameter itab, and when I wish to launch LDB program I got an error message, that one more parameter is missed (key date for open items).
So how does it work that LDB_PROCESS doesn't pass the key date parameter and it fetches data from LDBase correctly, whilst when I launch LDB manually from SE36 - it needs one more additional parameter?
Another thing is ... why when I set a breakpoint in LDB program, after launching F.05 - debugger does not stop at LDB's breakpoint ... I thought that when launching LDB_PROCESS sap launches a LDB's program to gather appropriate data ...
Greetings. P.
Edited by: Piotr Wojciechowski on Oct 30, 2009 2:12 PM
Edited by: Piotr Wojciechowski on Oct 30, 2009 2:12 PM

try transaction FBL3N with use LDB SDF, it uses flags to select cleared, non cleared or all items, depending on the flag selected some different dates are to be provided.
Regards,
Raymond

LDB_PROCESS for PNP

Hi all,
I am trying to use LDB_PROCESS function module for logical database PNP but am not sucessful in it.
I am pasting my code below:
Moderator message - Please respect the 2,500 character maximum when posting. Post only the relevant portions of code
The problem i am facing is that the FM is processed perfectly but callback routine is not called.
Kindly help...
Seema Peswani
ABAP HR
Edited by: Rob Burbank on Nov 13, 2009 9:43 AM

CALLBACK_WA-LDBNODE = 'PERNR'.
CALLBACK_WA-GET = 'X'.
*CALLBACK_WA-GET_LATE = 'X'.
CALLBACK_WA-CB_PROG = SY-REPID.
CALLBACK_WA-CB_FORM = 'CALLBACK_LFB1'.
APPEND CALLBACK_WA TO CALLBACK.
SELTAB_WA-KIND = 'S'.
SELTAB_WA-SELNAME = 'KD_ABKRS'.
LOOP AT S_ABKRS.
MOVE-CORRESPONDING S_ABKRS TO SELTAB_WA.
APPEND SELTAB_WA TO SELTAB.
ENDLOOP.
CALL FUNCTION 'LDB_PROCESS'
EXPORTING
    LDBNAME                     = 'PNP'
    VARIANT                     = ' '
    EXPRESSIONS                 = TEXPR
    FIELD_SELECTION             = FSEL
    DYN_NODE_TYPES              = DYN_NODE_TYPES
TABLES
    CALLBACK                    = CALLBACK
    SELECTIONS                  = SELTAB
EXCEPTIONS
    LDB_NOT_REENTRANT           = 1
    LDB_INCORRECT               = 2
    LDB_ALREADY_RUNNING         = 3
    LDB_ERROR                   = 4
    LDB_SELECTIONS_ERROR        = 5
    LDB_SELECTIONS_NOT_ACCEPTED = 6
    VARIANT_NOT_EXISTENT        = 7
    VARIANT_OBSOLETE            = 8
    VARIANT_ERROR               = 9
    FREE_SELECTIONS_ERROR       = 10
    CALLBACK_NO_EVENT           = 11
    CALLBACK_NODE_DUPLICATE     = 12
    CALLBACK_NO_PROGRAM         = 13
    CALLBACK_NO_CBFORM          = 14
    DYN_NODE_NO_TYPE            = 15
    DYN_NODE_INVALID_TYPE       = 16
    OTHERS                      = 17.
IF SY-SUBRC NE 0.
WRITE: 'Exception with SY-SUBRC', SY-SUBRC.
ENDIF.
FORM CALLBACK_LFB1 USING NAME TYPE LDBN-LDBNODE
                         WA TYPE PERNR
                         EVT TYPE C
                         CHECK TYPE C.
CASE EVT.
    WHEN 'G'.
      WRITE: / WA-PERNR.
   WHEN 'L'.
     ULINE.
ENDCASE.
ENDFORM.                    "CALLBACK_PERNR

Ldb_process and PNP

Hi,
could you give me a working example of using FM LDB_PROCESS with logical dabase PNP, please? Every example, which I found there dont work and I dont know why.
Thanks in advance
Krzysztof

hi,
Have you solved this problem yet or not? Please do reply. I am stuck with the same problem
would appreciate your effort.
thank you for your time and support.
Regards,
Seema Peswani

FM LDB_PROCESS doesn't work fine

Hi everyone,
I need to access the logical database EHS_OH001 from a function, and I using the FM LDB_PROCESS to do this.
But when I've compared teh results using this LDB via a report (selection screen and GET event) and this function I noticed that the results don't match, I mean, the report resulted 1 record while the function didn't bring any record at all.
The code is below...thanks in advance!
report zteste_ldb_process.
tables: ehs_pernr.
type-pools: rsds, rsfs.
data: texpr type rsds_texpr,
      fsel type rsfs_fields.
data : ti_pernr   type standard table of ehs_pernr with header line.
data: t_callback type table of ldbcb.
data:callback_wa like line of t_callback.
data: seltab type table of rsparams,
      seltab_wa like line of seltab.
select-options: s_pernr for ehs_pernr-person_id.
*parameters: p_pernr type ehs_pernr.
*parameters: p_plans type plans.
parameters: p_bukrs like ehs_pernr-bukrs obligatory modif id sel.
*parameters: zpgroup like hrp9904-zpgroup.
*parameters: znumber like hrp9904-zpnumber.
start-of-selection.
loop at s_pernr.
    move-corresponding s_pernr to seltab_wa.
    seltab_wa-kind = 'S'.
    seltab_wa-selname = 'EHSPERNR'.
    append seltab_wa to seltab.
endloop.
    seltab_wa-sign = 'I'.
    seltab_wa-option = 'EQ'.
    seltab_wa-kind = 'P'.
    seltab_wa-low = p_bukrs.
    seltab_wa-selname = 'EHSBUKRS'.
    append seltab_wa to seltab.
callback_wa-ldbnode = 'EHS_PERNR'.
callback_wa-get = 'X'.
callback_wa-get_late    = 'X'.
callback_wa-cb_prog = sy-repid.
callback_wa-cb_form = 'CALLBACK_EHS_PERNR'.
append callback_wa to t_callback.
call function 'LDB_PROCESS'
    exporting
      ldbname                           = 'EHS_OH001'
    variant                           = ' '
    expressions                       = texpr
    field_selection                   = fsel
DYN_NODE_TYPES                    =
    tables
      callback                          = t_callback
     selections                        = seltab
exceptions
   ldb_not_reentrant                 = 1
   ldb_incorrect                     = 2
   ldb_already_running               = 3
   ldb_error                         = 4
   ldb_selections_error              = 5
   ldb_selections_not_accepted       = 6
   variant_not_existent              = 7
   variant_obsolete                  = 8
   variant_error                     = 9
   free_selections_error             = 10
   callback_no_event                 = 11
   callback_node_duplicate           = 12
   callback_no_program               = 13
   callback_no_cbform                = 14
   dyn_node_no_type                  = 15
   dyn_node_invalid_type             = 16
   others                            = 17
if sy-subrc <> 0.
MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
        WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
endif.
*&      Form CALLBACK_EHS_PERNR
      Função usada por LDB_PROCESS para processar os nodes.
     -->P_EHS_PERNR text
     -->P_WA text
     -->P_EVT text
     -->P_CHECK text
form callback_ehs_pernr using    p_ehs_pernr type ldbcb-ldbnode
                                  p_wa type ehs_pernr
                                  p_evt type c
                                  p_check type c.
append p_wa to ti_pernr.
endform.                    " CALLBACK_EHS_PERNR

Hi Dave,
Pls. refer to the earlier posted forum. This may be helpful for ya..
Delta load from ODS to Cube
You may also look into
Delta Update from ODS is invalidated
this has been mentioned in the previous forum link .
Hope this helps...
Thanks,
Raj

Help needed on workin with LDBs using call through Function Module LDB_PROC

Hi All
I am new to Logical Databases. I found on net that I can use a dynamic call to a Logical Database using Function Module
"LDB_PROCESS".
I tried implementing the same using the following logic.
REPORT zsa_test2.
TABLES: pernr.
SELECT-OPTIONS s_pernr FOR pernr-pernr.
DATA: callback TYPE TABLE OF ldbcb,
           callback_wa LIKE LINE OF callback.
callback_wa-ldbnode     = 'PERNR'.
callback_wa-get            = 'X'.
callback_wa-cb_prog     = sy-repid.
callback_wa-cb_form     = 'CALLBACK_PERNR'.
APPEND callback_wa TO callback.
START-OF-SELECTION.
CALL FUNCTION 'LDB_PROCESS'
       EXPORTING
            ldbname                       = 'PNP'
         VARIANT                       = ' '
         EXPRESSIONS              = TEXPR
         FIELD_SELECTION        = FSEL
       TABLES
            callback                         = callback
         SELECTIONS                 = SELTAB
    EXCEPTIONS
         LDB_NOT_REENTRANT      = 1
         LDB_INCORRECT               = 2
         LDB_ALREADY_RUNNING = 3
         LDB_ERROR                      = 4
         LDB_SELECTIONS_ERROR = 5
         LDB_SELECTIONS_NOT_ACCEPTED = 6
         VARIANT_NOT_EXISTENT      = 7
         VARIANT_OBSOLETE            = 8
         VARIANT_ERROR                  = 9
         FREE_SELECTIONS_ERROR = 10
         CALLBACK_NO_EVENT         = 11
         CALLBACK_NODE_DUPLICATE     = 12
         OTHERS                                       = 13.
IF sy-subrc <> 0.
   WRITE: 'Exception with SY-SUBRC', sy-subrc.
ENDIF.
*&      Form CALLBACK_SPFLI
      text
     -->NAME       text
     -->WA         text
     -->EVT        text
     -->CHECK      text
FORM callback_pernr USING name TYPE ldbn-ldbnode
                                            wa    TYPE pernr
                                            evt   TYPE c
                                            check TYPE c.
BREAK-POINT.
WRITE: / wa-pernr.
ULINE.
ENDFORM.                    "CALLBACK_SPFLI
But I am unable to transfer the control to the subroutine. The break-point isn't reached.
Can someone please guide me? Am I using the wrong node or something??

look at the below code ..
pass sstab to the selection in the FM
data cbtab type table of ldbcb.
data wa_cbtab like line of cbtab.
data sstab type table of rsparams.
data wa_sstab like line of sstab.
wa_cbtab-ldbnode = 'SPFLI'.
wa_cbtab-get      = 'X'.
wa_cbtab-get_late = ' '.
wa_cbtab-cb_prog = sy-cprog.
wa_cbtab-cb_form = 'CB_SPFLI'.
append wa_cbtab to cbtab.
wa_cbtab-ldbnode = 'SFLIGHT'.
wa_cbtab-get      = 'X'.
wa_cbtab-get_late = ' '.
wa_cbtab-cb_prog = sy-cprog.
wa_cbtab-cb_form = 'CB_SFLIGHT'.
append wa_cbtab to cbtab.
wa_sstab-selname = 'AIRP_FR'.
wa_sstab-kind     = 'S'.
wa_sstab-sign     = 'I'.
wa_sstab-option   = 'EQ'.
wa_sstab-low      = 'FRA'.
append wa_sstab to sstab.
call function 'LDB_PROCESS'
exporting
    ldbname     = 'F1S'
tables
    callback    = cbtab
    selections = sstab .
form cb_spfli using nodename type ldbn-ldbnode
                      wa_spfli type spfli
                      mode      type c
                      selected type c.
   write: / wa_spfli-carrid,
            wa_spfli-connid,
            wa_spfli-airpfrom,
            wa_spfli-airpto.
endform.
form cb_sflight using nodename   type ldbn-ldbnode
                        wa_sflight type sflight
                        mode       type c
                        selected   type c.
   write: /3 wa_sflight-fldate,
             wa_sflight-seatsmax,
             wa_sflight-seatsocc.
endform.

Help on FM LDB_PROCESS for LDB FTI_TR_PL_CF

Hi everyone,
Good day!
I am currently working on INFOSETS for Treasury Module and there's a requirement to use function module LDB_PROCESS for logical database FTI_TR_PL_CF.
I have not worked on the said function module before and i am not familiar with the logical database.
In this regard, I would like to ask you good Sirs and Madams to give me an overview or any input that would give me a clear picture on what needs to be done for this requirement.
Thanks so much in advance.
God bless!
Regards,
Mike

Hi Suresh,
Thanks for your help.
Does anyone know a link that shows how to create infoset query using the FM LDB_PROCESS? I have been working on this for days now and I'm still kind of puzzled. The requirement is to add output fields to the query but the fields to be displayed are to be retrieved from an outside Logical database. Hope you guys can also help me on this.
Thanks so much in advance. God bless!
Regards,
Mike

FTI_TR_POSITIONS with LDB_PROCESS

Similar Messages

Maybe you are looking for