3.1.

TIPOS Y OBJETOS de datos

3.2. Tablas internas

3.3. Sentencias para abandonar

bloques de proceso

3.4. SENTENCIAS DECLARATIVAS

3.5. SENTENCIAS DE PROCESAMIENTO

DE DATOS

3.5.1. Sentencias de asignación y

conversión de variables
3.5.2. Sentencias de cálculo
3.5.3. Sentencias de manejo de
strings

3.1. TIPOS Y OBJETOS DE datos:

Pueden declararse tipos de datos (son descripciones que definen los objetos de datos que se
declaren luego, y no ocupan memoria) y objetos de datos (entidades físicas que sí ocupan
memoria: variables. Tienen un tipo asociado, y se procesan según el tipo que sea).

 Tipos de datos:Por su estructura se clasifican

en elementales(predefinidos: C, D, F, I, N, P, T, X. Estos nombres son fijos;
y definidos por el usuario: a partir de los anteriores. Su nombre es libre)
y estructurados(predefinidos: tablas del Diccionario de Datos (se declaran
con TABLES); y definidos por el usuario: field-strings y tablas internas (ambos
se declaran con DATA)).

Long. Long. Máx. (nº

TIPOS ELEMENTALES: Tipo Valor inicial
defecto char)
Alfanumérico (Char,
C 1 de 1 a 65535 SPACE
string)
Fecha(Date) D 8 8 '00000000'
Coma flotante (Float) F 8 8 0.0
Entero (Integer) I 4 4 0
Numéricos (Natural) N 1 de 1 a 65535 '0...0'
Empaquetados (Packed) P 8 de 1 a 16 0
Hora (Time) T 6 6 '000000'
Hexadecimales (Hex) X 1 de 1 a 65535 X'00'


La longitud se mide en caracteres, NO en bytes. Variables que no sean del mismo tipo
exactamente pueden no ser totalmente compatibles, lo que puede provocar errores de
conversiones numéricas. Por ej., para operaciones de división usar el tipo P (packed), al menos
para el recoger el resultado.

 Objetos de datos: Se clasifican en los siguientes grupos:

o Internos:Literales (‘hardcodes’ de texto y números. No se declaran),
variables (se declaran con DATA) y constantes (se declaran
con CONSTANTS).
o Externos: objetos del Diccionario Datos: tablas (se declaran
con TABLES), obj. matchcode.
o Del Sistema: No se declaran, como SPACE, que es un espacio o una
cadena en blanco, y campos y variables del sistema (Ej,: SY-SUBRC:
código de retorno de una operación; SY-UNAME: nombre de
usuario; SY-REPID: código de report).
o Especiales:parámetros (variables que toman su valor en la pantalla de
selección. Se declaran con PARAMETERS), y criterios de selección (Se
declaran con SELECT-OPTIONS).

3.2. TABLAS INTERNAS:

Las tablas internas son las creadas como locales en un programa; no pertenecen al Diccionario
de Datos. Sólo son visibles localmente en el programa en el que se declaran. Se declaran con:

DATA: BEGIN OF nombre_tabla OCCURS núm_entradas, ... END OFnombre_tabla.

 Con OCCURS se especifica el número de líneas, registros o entradas máximo de

la tabla. Sin este parámetro se declaran estructuras, que son cabeceras de
tablas, es decir, no tienen entradas.
 Las tablas internas tienen un registro de cabecera, del mismo formato que
cada entrada de la tabla, que es como un buffer que sirve para insertar o extraer
entradas de ellas.
 Para insertar datos, se usa un MOVE normal para cada campo, con lo que se
rellena la cabecera con los valores adecuados, y luego un APPEND nombretabla.
Así se inserta dicha cabecera como una nueva entrada en la tabla). También se
puede usar la sentencia COLLECT, que es similar a APPEND, salvo que si se
inserta una entrada cuya clave ya existe, en lugar de crear una nueva, se suman
los contenidos de los campos numéricos no clave (si no hay, es como APPEND).
 Para extraer datos, se debe recorrer la tabla (con un bucle LOOP
AT nombre_tabla, por ejemplo) hasta llegar a la entrada buscada. Entonces,
automáticamente ya se tendrá en el registro cabecera de la tabla dicha entrada,
accesible directamente.
 Con la sentencia CLEAR se limpia o borra el registro de cabecera (pone todos
los campos a su valor inicial), pero no borra ninguna entrada de la tabla. En
cambio con REFRESH se borran todas las entradas de la tabla, salvo la
cabecera. Con FREE se eliminan la tabla y su cabecera.
 Conviene controlar con un IF o un CHECK si la tabla está vacía o no antes de
intentar imprimirla. Se puede usar la sentencia DESCRIBE
TABLE tabla LINES nr_líneas. para guardar en la variable nr_líneas el número
de líneas de la tabla, y así ver si es cero o no.

 Para ordenar la tabla, usar la sentencia SORT nombre_tabla BY campo [

opciones].
 Ej.:
 TABLES kna1.
"tabla de los datos maestros de los
clientes.

DATA: BEGIN OF ztabla OCCURS 100,

"declara una tabla con 2 campos y 100
entradas
nombre LIKE kna1-name1,
cliente LIKE kna1-kunnr.
DATA: END OF ztabla.

REFRESH ztabla. " borra todas

las entradas de la tabla, para asegurar
que está vacía
CLEAR ztabla. " borra el
registro de cabecera de la tabla, por si
era un valor basura

SELECT * FROM kna1.

MOVE kna1-kunnr TO ztabla-cliente.
MOVE kna1-name1 TO ztabla-nombre.
APPEND ztabla. " para insertar
efectivamente en la tabla
END-SELECT.

IF sy-subrc <> 0.
WRITE ‘No se ha encontrado ningún
dato’.
ELSE.
LOOP AT ztabla. " bucle que
recorre la tabla, para imprimirla entera
WRITE: ztabla-nombre, ztabla-
cliente.
END-LOOP.
ENDIF.

3.3. Sentencias para abandonar bloques de proceso:

Dichas sentencias son: STOP, EXIT, CHECK y REJECT. Son todas incondicionales
salvo CHECK. La sentencia CONTINUE vale para pasar a la siguiente vuelta de un bucle.

 STOP.
Incondicional. Se debe usar sólo en el evento START-OF-SELECTION. Su
efecto es cancelar todas las selecciones de las tablas de la base de datos,
abandonando el evento, y activar el END-OF-SELECTION (siempre lo activa. Si
no se desea esto, debe usarse EXIT en lugar de STOP).
 EXIT.
Incondicional. Abandona totalmente el bloque actual o evento (excepto
eventos AT...) si no está dentro de ningún bloque, y activa la pantalla de salida.
Puede usarse fuera de bucles (acaba subrutinas, acaba eventos, ...) o dentro de
ellos, para finalizar estos.
 CHECK { condición | tabla_selección | SELECT-OPTIONS }.
Condicional. Si la condición es falsa, acaba el bloque de proceso o evento (si no
está dentro de ningún bloque) actual; si es cierta, sigue (como si no hubiera
ningún CHECK). Es decir, que si no se “pasa” el chequeo, se salta a la siguiente
vuelta del bucle (funciona como un CONTINUE condicional), o abandona la
 subrutina, ... (funciona como un EXIT condicional). La opción SELECT-
OPTIONS sólo puede usarse para CHECKs que vayan tras eventos GET. Su
efecto es comprobar que la entrada leída de la tabla cumpla todos los criterios
de selección asociados.
 REJECT [ tabla_bd ].
Incondicional. Tras REJECT, se procesa el siguiente evento GET para la misma
tabla, abandonando la selección actual. Opcionalmente se puede indicar una
tabla de la base de datos jerárquicamente superior, con lo cual, tras
ejecutar REJECT se procesa el siguiente GET de la tabla especificada (la
siguiente “vuelta” del GET; la “vuelta” actual se abandona).
 CONTINUE.
Incondicional. Termina la vuelta de un bucle (DO, WHILE), de forma
incondicional, pasando a la siguiente vuelta. Normalmente sólo se puede usar
dentro de un bucle de ese tipo.

3.4. SentenCIAS DECLARATIVAS:

 TABLES tabla.
Así se declara el área de trabajo de la tabla del D.D. especificada, para poder
usarla.
 DATA variable [ (long) ] [ TYPE tipo | LIKE campo ] [ DECIMALS núm ]
[ VALUE valor ].
Versión de DATA para declarar variables. El tipo por defecto
es C (alfanumérico) y la longitud por defecto es la definida así para cada tipo
(para los tipo C, longitud 1: un carácter). Otros tipos de datos simples
son: I (integer), P (numérico empaquetado), N (numérico no
empaquetado), D (date), ... Con LIKE, se toma como tipo el mismo que tenga
el campo especificado. Con VALUE se inicializa a la vez que se declara. Ejemplo
de sentencias DATA encadenadas:

DATA: texto1 TYPE C VALUE 'X',

texto2(4) TYPE C VALUE 'HOLA'.

 DATA: BEGIN OF nombre, ... END OF nombre.

Versión de DATA para field-strings: Los campos que se declaren en el field-
string (es como un registro de cadenas) van separados por comas, y en cada
uno se indica su tipo. Para acceder a ellos se escribe:
nombre_registro – nombre_campo, de forma análoga a las tablas.
 DATA: BEGIN OF nombre_tabla OCCURS núm_entradas, ... END
OFnombre_tabla.
Versión de DATA para tablas internas (son las creadas como locales en un
programa; no pertenecen al Diccionario de Datos. Sólo son visibles en dicho
programa. Con OCCURS se indica el número máximo de entradas. Si se pone 0,
el tamaño de la tabla no tiene límite sintácticamente) o estructuras (no
llevan OCCURS. Son como cabeceras de tablas, es decir, “tablas” sin entradas).
 DATA: BEGIN OF COMMON PART nombre, ... END OF COMMON PART.
DATA para bloques de memoria comunes. Esto define una zona común de
memoria que puede ser compartida por varios programas, si se declara en todos
ellos (con el mismo nombre). Dentro de la "common part" se declaran las
variables, tablas internas, ... que deban ser compartidas.
 TYPES tipo [ longitud ] [ TYPE tipo | LIKE campo ] [ DECIMALS número ].
Para definir tipos de datos internos al programa. Para tipos estructurados
 (como registros o tablas. A los campos de ambos se accede con nombre–campo)
puede usarse TYPES de forma encadenada: TYPES: BEGIN OF nombre,
... END OF nombre. También vale para tipos específicos de usuario.
Ejemplo: TYPE cadena(30) TYPE C. Declara un string de 30 caracteres.
 CONSTANTS cons [ long ] [ TYPE tipo ] VALUE valor | IS
INITIAL [ DECIMALS núm ].
Sintaxis similar a la de DATA, pero para constantes simples. El
parámetro VALUE es obligatorio. Con IS INITIAL, las constantes alfabéticas se
inicializan a blanco, y las numéricas a cero.
 CONSTANTS: BEGIN OF nombre, ... END OF nombre.
Versión de CONSTANTS para registros constantes (como tablas constantes).
Se accede a las componentes de un registro constante como si fuera una tabla
interna.
 FIELD-GROUPS nombre.
Un field-group es una agrupación de campos (es un registro interno de
strings). Con esta sentencia se declara el nombre del grupo (conjunto) de
campos. Se crea un field-group, aún sin campos. Después, con la
sentencia INSERT se declaran los campos de que constará el conjunto (que
deben existir previamente), y con la sentencia EXTRACT se dan valores a esos
campos. No se reserva espacio de memoria para dichos campos, pues sólo serán
punteros a las variables correspondientes. No confundir esta sentencia
con FIELD-SYMBOLS.
 INCLUDEnombre.
Inserta el código fuente especificado (debe ser un programa tipo I
de Include, no puede ser un programa on-line) en el lugar del programa
principal donde esté esta sentencia INCLUDE. Normalmente habrá uno para las
declaraciones globales (llamado include ‘TOP’) que usen varios programas,
otro(s) para los procesos PBO (Process Before Output: se ejecutan antes de
mostrar la pantalla de selección), otro(s) para los procesos PAI (Process After
Input: se ejecutan después de que el usuario haya hecho las selecciones de
dicha pantalla, y haya lanzado el programa), como en un module pool típico.
Para usar en el programa estructuras ya definidas antes, se usa INCLUDE
STRUCTURE para definir así tablas internas.

Ejemplo:

* Equivale a DATA tabla LIKE namestruct

OCCURS n.
DATA: BEGIN OF tabla OCCURS n.
INCLUDE STRUCTURE namestruct.
DATA: END OF tabla.


 LOCAL variable.
Se usa para declarar variables locales dentro de subrutinas
(FORM ... ENDFORM). Si existe una variable global de mismo nombre, se salva
su valor al entrar en la subrutina, y se restaura al salir, es decir, que la variable
local deja de existir fuera de la subrutina.
 STATICS var [ long ] [ TYPEtipo ] [ VALUE valor | IS
INITIAL ][ DECIMALS num ].
También para variables locales. Se usa sólo dentro de FORMs (subrutinas).
Funciona como LOCAL, pero con la diferencia de que conserva a la salida de la
subrutina el valor que se le dé dentro de ésta, en lugar de restaurar el valor
previo: pero la variable sólo será visible en los procesos en los que esté definida.
 STATICS: BEGIN OF nombre, ..., END OF nombre.
Se usa para declarar un field string dentro de una subrutina o módulo de
 función. Es similar a un DATA, pero es local al subprograma en el que se defina,
y en sucesivas llamadas al mismo conserva su valor (no es destruido como
ocurre con las variables locales; es estático).
 RANGES tabla_selección FOR campo.
Define una tabla interna con igual estructura que la de un select-options.
Permite usar IN (puede recoger un intervalo de valores). La diferencia es que en
la pantalla de selección no aparece esta tabla de selección, cosa que ocurriría
con un SELECT-OPTIONS (así puede dársele valor por programa, en lugar de
que lo haga el usuario). Formato de esta tabla:

DATA: BEGIN OF tabla OCCURS 0,

SIGN(1) TYPE C,
OPTION(2) TYPE C,
LOW LIKE campo,
HIGH LIKE campo.
DATA: END OF tabla.

 Tiene 4 campos: El campo SIGN indica si los valores frontera del intervalo
(campos LOW y HIGH) están incluidos (‘I’) o excluidos. El
campo OPTION puede ser: EQ (=), NE (<>), CP (contiene pattern), NP (no
contiene pattern), BT (between), GT (>), LT (<), GE (>=), LE (<=). Los
campos LOW y HIGH definen el intervalo o rango de valores (si es un valor
individual sólo se rellena (en) LOW). Esta tabla tendrá una entrada
por cada intervalo o valor individual definido. Todos estos campos son accesibles
y modificables como los de cualquier otra tabla.
 TYPE-POOL nombre_tipo.
Para declarar grupos de tipos. Se acceden con la transacción SE11 (Diccionario
de Datos, que es donde se guarda la estructura del TYPE-POOL). En ellos sólo
pueden definirse constantes y tipos (con TYPE), y deben nombrarse empezando
con el nombre del grupo de tipos seguido de ‘_’. Al ser objetos del D.D. podrán
ser visibles en todos los programas SAP. Para llamarlos o acceder a ellos desde
un programa se usa la sentencia (distinta) TYPE-POOLS.
Ejemplo de declaración:

* Se define el 'TIPO1' como agrupación

de un P y de un I.
TYPE-POOL tipo1.
TYPES: tipo1_packed TYPE P,
tipo1_entero TYPE I.


 TYPE-POOLS nombre_tipo.
Sentencia que sirve para acceder o llamar a un TYPE-POOL almacenado ya en
el D.D.
Ejemplo:

* Con esto ya es visible en el programa

el 'TIPO1' antes creado.
TYPE-POOLS tipo1.
 * Se usa 'TIPO1' como cualquier otro
predefinido
DATA: campo TYPE tipo1_entero.

 DESCRIBE FIELD var [ LENGTH long ] [ TYPE tipo ] [ COMPONENTS comps ]

[ OUTPUT-LENGTH long ] [ DECIMALS decimales ] [ EDIT MASK mascara ].
Sirve para determinar los atributos del objeto dado. Si al intentar acceder a él,
éste existe, SY-SUBRC valdrá cero; en otro caso, distinto de cero. No confundir
esta sentencia con DESCRIBE TABLE, que es análoga pero para tablas internas
en lugar de variables simples.
 CREATE OBJECT objeto clase [ LANGUAGE lenguaje ].
Crea un objeto de la clase especificada. Se usa para declarar objetos OLE (por
ejemplo, para asociar un fichero EXCEL a un report Abap/4).
 FIELD-SYMBOLS<nombre_símbolo> [ STRUCTURE estructura DEFAULT valor
] [ TYPE [ LINE OF ] tipo ] [ LIKE [ LINE OF ] tipo ].
Con esta sentencia se pueden declarar campos simbólicos. En ejecución, con
la sentencia ASSIGN, pueden asignárseles campos concretos, de forma
dinámica, en lugar de los campos
simbólicos. Sintaxis: ASSIGN campo1 TO<nombre_símbolo>. (los < >son
obligatorios). “campo1” puede ser de cualquier tipo. Más tarde en el programa
puede haber otra sentencia como: ASSIGN campo2 TO<nombre_símbolo>.,
con “campo2” de cualquier otro tipo (hay un polimorfismo de datos en
ejecuc.). Con la opción STRUCTURE se asignarán estructuras al field-symbol.
Sus campos se accederán con <fs>_campo. Con LINE OF se puede dat una
tabla interna. No confundir esta sentencia con FIELD-GROUPS.
Ejemplo:

* Con esto ya está declarado el campo

simbólico
FIELD_SYMBOLS < mi_símbolo >.

DATA: campo1(2) TYPE C VALUE 'AA',

campo2(2) TYPE P VALUE 34.
……
ASSIGN campo1 TO < mi_símbolo >. "Aquí
mi_símbolo es de tipo C y vale 'AA'
……
ASSIGN campo2 TO < mi_símbolo >. "Ahora
mi_símbolo es de tipo P y vale 34
(polimorfismo)

 SELECTION-SCREEN, PARAMETERS, y SELECT-OPTIONS

Son sentencias declarativas de la pantalla de selección.
 DESCRIBE TABLE, WRITE … TO … INDEX, CLEAR y FREE
Son sentencias Native SQL.

 3.5. Sentencias de procesamiento de datos:

3.5.1. Sentencias de asignación y conversión de variables:

 MOVE campo1[offset1] TO campo2[offset2] [ PERCENTAGE nr ].

  MOVEcopia el contenido del campo1 en campo2. Los offset permiten
especificar sólo una parte del campo origen y/o destino, y se escriben
así: +número, todo pegado al nombre del campo.
En PERCENTAGE puede especificarse un %, es decir, 0 < nr < 100 (si
se usa esta opción, ‘campo1’ y ‘campo2’ deben ser tipo C. El resultado es
que el nr % de ‘campo1’ se mueve a ‘campo2’ justificado a la
[Link] hace conversiones de formato, si origen y
destino no tienen igual tipo, lo que puede dar lugar a resultados
erróneos.
 MOVE–CORRESPONDING tabla1 TO tabla2.
 Sentencia similar a MOVE, pero de un registro o cabecera de una tabla a
otra igual (o no) en estructura. Si origen y destino no coinciden en todos
los campos (en la estructura) sólo se mueven aquellos campos
que coincidan (por nombre, no por posición. Por tanto, para evitar
errores de conversión, ambos campos de mismo nombre también
deberían tener el mismo tipo y tamaño).
 WRITE campo1[offset1] TO campo2[offset2].
 Similar a MOVE, salvo que el “campo2” (destino) siempre debe ser de
tipo texto. Por tanto, si el origen no es de texto, será convertido. Pueden
especificarse offsets a la hora de hacer estas conversiones. Con WRITE
(campo1) TO … no se mueve campo1 (va entre paréntesis), sino
su contenido (es una indirección).
 PACK campo TO campo.
 Convierte ese campo a su forma empaquetada, por ejemplo,
números sin ceros a la izquierda. Puede escribirse el resultado sobre la
misma variable, o en otra distinta.
 UNPACK campo TO campo.
 La operación inversa a PACK (es decir, convierte el campo a su
forma desempaquetada). Ejemplo, rellenar con ceros a la izquierda un
número, hasta completar la longitud del campo.
 CONVERT DATE e INVERT DATE
 Sentencias de conversión de fechas a formato interno de SAP (poco
útil).
 CONVERT TEXT campo1 INTO SORTABLE CODE campo2.

Sentencia que transforma un campo de texto simple a un campo tal que es más
rápidamente ordenable, insertando índices, claves, …

3.5.2. Sentencias de cálculo:

 ADD campo2 TO campo1.

Hace la operación: campo1 := campo1 + campo2. Las demás sentencias de
cálculo son similares: en “campo1” se almacenará el resultado de la operación.
 ADD n1 THEN n2 UNTIL ni GIVING | TO m.
Hace la operación: m := m + n1 + n2 + … + ni. Se incluye ‘m’ como sumando o
no dependiendo de si se usa GIVING o TO.
 ADD-CORRESPONDING tabla2 TO tabla1.
Suma los campos que se correspondan (por su nombre) de 2 registros o
tablas, y deja los nuevos valores en el segundo de ellos (“tabla1”).
 SUBSTRACT campo2 FROM campo1.
 SUBSTRACT-CORRESPONDING tabla2 FROM campo1.
 MULTIPLY campo1 BYcampo2.
  MULTIPLY-CORRESPONDING tabla1 BY tabla2.
 DIVIDE campo1 BY campo2.
 DIVIDE-CORRESPONDING tabla1 BY tabla2.
 COMPUTEn = expresión.
Permite realizar cualquiera de las operaciones aritméticas permitidas:
o Operaciones básicas: +, -, *, /, MOD, ** (exponenciación). Cubren las
sentencias anteriores.
o Para todo dato numérico: ABS, CEIL (función techo), FLOOR (función
suelo), SIGN (devuelve el “valor” del signo: -1, 0, 1), TRUNC (devuelve
la parte entera), FRAC (devuelve la parte fraccionaria).
o Para coma
flotante: COS, SEN, TAN, ACOS, ASEN, ATAN, COSH, SENH, TANH,
EXP (en base e), LOG (en base e), LOG10 (en base 10), SQRT.

3.5.3. Sentencias de manejo de strings:

 CONCATENATE c1 … cn [ SEPARATED BY separador ] INTO campo.

Concatena los strings c1 … cn (deben ser todos de tipo C), sin conversión de
tipos. Devuelve SY-SUBRC 0 si la operación se ha completado correctamente, y
4 si el campo destino es demasiado pequeño para guardar la concatenación.
 SET LOCALE LANGUAGE lenguaje [ COUNTRY país
][ MODIFIER modificador].
 CONDENSE campo [ NO-GAPS].
El “campo” debe ser tipo C (una cadena), o bien lo trata como si lo fuera (por
ejemplo, no incluye en los números el carácter blanco inicial). Junta las palabras
de campo dejando entre ellas sólo un blanco. Con NO-GAPS se eliminan todos
los blancos.
 REPLACE string1 WITH string2 INTO campo [ LENGTH long ].
Reemplaza (sólo la primera ocurrencia) de “string1” por “string2” en el valor de
“campo”.
Ejemplo:

REPLACE 'B' WITH 'hola' INTO campo.


Si "campo" era 'ABCB', el resultado será 'AholaCB' (reemplaza sólo la primera
ocurrencia). Devuelve código de retorno 0 si la operación fue correcta, y 4 si
hubo algún error.

 SPLIT campo AT separador INTO c1 … cn | INTO TABLE tabla.

Parte “campo” en n partes, delimitadas por el separador dado, como ‘/’ por
ejemplo. Devuelve SY-SUBRC 0 si los campos c1 … cn tienen espacio suficiente,
y 4 en caso contrario (los trunca).
 SHIFT campo [ BY n PLACES ] [ UP TO campo1 ] [ LEFT | RIGHT ]
[ CIRCULAR ][ LEFT DELETING LEADING campo1 ] [ RIGHT DELETING
TRAILING campo1 ].
Desplaza “campo” n posiciones (1 por defecto) a la izquierda o derecha, de
forma circular o no (según se especifique) Rellena con blancos al desplazar.
 TRANSLATE campo [TO UPPER CASE | TO LOWER CASE ] [ USING campo1
][FROM CODE PAGE g1 TO CODE PAGE g2 ] [ FROM NUMBER
 FORMAT n1TONUMBER FORMAT n2 ].
Según se especifique, pasa el campo dado a mayúsculas o a minúsculas.
 OVERLAY campo1 WITH campo2 [ ONLY campo3 ].
El contenido de ‘campo2’ sobreescribe a ‘campo1’ en todas las posiciones
donde ‘campo1’ tenga blancos, reemplazándolos por los caracteres de ‘campo2’
de las posiciones respectivas (por defecto se reemplazan blancos. Se puede
especificar el carácter o caracteres a reemplazar en ‘campo3’. Se sustituyen
todos los caracteres que se especifiquen en este campo, y se encuentren en
‘campo1’, pero sueltos, no formando un string). Devuelve 0 si al menos un
carácter ha sido sobrescrito, y 4 en otro caso.
Ejemplo:

OVERLAY 'AAAMMBBCCA' WITH 'ZXCVBNMASS'

ONLY 'AB'.
*Resultado --> 'ZXCMMNMCCS'

 SEARCH { campo | tabla } FOR criterio [ ABBREVIATED ][ STARTING

AT inicio ][ ENDING AT final ] [ AND MARK ].
Busca en el 'campo' dado el string 'criterio'. Con ABBREVIATED se busca algo
que empiece por las mismas letras que 'criterio'. Se puede delimitar la búsqueda
especificando las posiciones de inicio y fin con STARTING AT y ENDING AT.
Con AND MARK se señala en mayúsculas la palabra en la que se encontró el
string. Devuelve 0 si encontrado (estará en la posición SY-FDPOS), y 4 en otro
caso.
BAPI_EXCHANGERATE_GETDETAIL SAP Function module - Exchange
Rate Stored for [Link] Type, Currency Pair, Value Date

BAPI_EXCHANGERATE_GETDETAIL is a standard SAP function module available

within R/3 SAP systems depending on your version and release level. Below is the
pattern details for this FM showing its interface including any import and export
parameters, exceptions etc as well as any documentation contributions
(Comments) specific to the object.

See here to view full function module documentation and code listing, simply by
entering the name BAPI_EXCHANGERATE_GETDETAIL into the relevant SAP
transaction such as SE37 or SE80.

Associated Function Group: BUS1093

Released Date: 11.10.2000
Processing type: Remote-Enabled

Pattern for FM BAPI_EXCHANGERATE_GETDETAIL - BAPI

EXCHANGERATE GETDETAIL

CALL FUNCTION 'BAPI_EXCHANGERATE_GETDETAIL' "Exchange Rate Stored for

[Link] Type, Currency Pair, Value Date
EXPORTING
rate_type = " bapi1093_1-rate_type Exchange Rate
Type
from_curr = " bapi1093_1-from_curr From Currency
to_currncy = " bapi1093_1-to_currncy To Currency
date = " bapi1093_2-trans_date Value Date
IMPORTING
exch_rate = " bapi1093_0 Exchange Rate, Factors
for Currency Pair
return = " bapiret1 Error Message
. " BAPI_EXCHANGERATE_GETDETAIL

ABAP code example for Function Module BAPI_EXCHANGERATE_GETDETAIL

The ABAP code below is a full code listing to execute function module
BAPI_EXCHANGERATE_GETDETAIL including all data declarations. The code uses
the latest in-line data DECLARATION SYNTAX but I have included an ABAP code
snippet at the end to show how declarations would look using the original method
of declaring data variables up front. This will allow you to compare and fully
understand the new inline method. Please note some of the newer syntax such as
the @DATA is not available until a later 4.70 service pack (SP8).

DATA:
ld_exch_rate TYPE BAPI1093_0 ,
ld_return TYPE BAPIRET1 .
DATA(ld_rate_type) = some text here
DATA(ld_from_curr) = Check type of data required
DATA(ld_to_currncy) = Check type of data required
DATA(ld_date) = 20210129.

CALL FUNCTION 'BAPI_EXCHANGERATE_GETDETAIL'

EXPORTING
rate_type = ld_rate_type
from_curr = ld_from_curr
to_currncy = ld_to_currncy
date = ld_date
IMPORTING
exch_rate = ld_exch_rate
return = ld_return
. " BAPI_EXCHANGERATE_GETDETAIL
IF SY-SUBRC EQ 0.
"All OK
ENDIF.

ABAP code to compare 7.40 inline data declaration with original

syntax

The below ABAP code uses the older none in-line data declarations. This allows you
to see the coding differences/benefits of the later inline syntax. It may also be
useful if you are using an older version of SAP as some of the newer syntax above,
such as the @DATA is not available until 4.70 EHP 8.

SAP Documentation for FM BAPI_EXCHANGERATE_GETDETAIL

The API method makes it possible to read an entry from the exchange rate table.
The system carries out an authorization check for ...See here for full SAP fm
documentation

Contribute (Add Comments)

Please help keep this info upto date and use the comments section below to add
useful hints, tips and information specific to this SAP function. This will then be
available for you and other users to easily find by simply searching on the object
name BAPI_EXCHANGERATE_GETDETAIL or its description.

BAPI_EXCHANGERATE_GETDETAIL - Exchange Rate Stored for [Link] Type,

Currency Pair, Value Date
BAPI_EXCHANGERATE_CREATE - Addition of Entry in Table of Exchange Rates
BAPI_ES_ROUTING_CHANGE - BAPI: Maintain Task List
BAPI_ERC_UPDATE_ATTACHMENT -
BAPI_ERC_READ_ATTACHMENTS -
BAPI_ERC_CHECK_ATTACHMENT -

*&---------------------------------------------------------------------*
*& Report ZPRUEBA_FECHA_TCAMBIO
*&---------------------------------------------------------------------*
*&
*&---------------------------------------------------------------------*
REPORT ZPRUEBA_FECHA_TCAMBIO.

DATA: wa_BAPI1093_0 TYPE BAPI1093_0.

START-OF-SELECTION.
perform obtener_valor.

form obtener_valor.
data:
ld_exch_rate type BAPI1093_0,
ld_rate_type type BAPI1093_1-rate_type,
ld_return type BAPIRET1,
ld_from_curr type BAPI1093_1-from_curr,
ld_to_currncy type BAPI1093_1-to_currncy,
ld_date type BAPI1093_2-trans_date.

"PRIMERA FORMA DE OBTENER LA TASA DE CAMBIO

ld_to_currncy = 'GTQ'.
ld_from_curr = 'USD'.
ld_rate_type = '20190325'.
ld_date = '20190325'.

CALL FUNCTION 'BAPI_EXCHANGERATE_GETDETAIL'

EXPORTING
RATE_TYPE = 'M' "ld_rate_type'
FROM_CURR = 'USD' "ld_from_curr
TO_CURRNCY = 'GTQ' "ld_to_currncy
DATE = ld_date
IMPORTING
EXCH_RATE = wa_BAPI1093_0.
"RETURN = return.

IF sy-subrc <> 0.
MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.

WRITE: / 'Valor de Tasa de Cambio: ',wa_BAPI1093_0-EXCH_RATE.

endform.

"Nota:
"CURRENCY: el tipo de moneda para el cambio
"‘USD’ : el tipo de cambio que se desea obtener
"EXCHANGE_RATE_DATE: Fecha del día.
"exch_rate: Datos obtenidos
CREAR Y GESTIONAR BANCOS EN SAP Una de las transacciones que
encontramos en la carpeta de Finanzas, es la que nos va a
permitir crear bancos para poder posteriormente trabajar con el resto
de transacciones que necesitan de un banco, como la contabilidad,
gestión de cobros, etc., Accederemos al esquema de carpetas, Finanzas 
[Link]  Bancos  Datos Maestros  Maestro
de bancos  Crear O directamente con la transacción FI01

23.- CREAR Y GESTIONAR BANCOS EN SAP

Una de las transacciones que encontramos en la carpeta de Finanzas, es la que nos va a
permitir crear bancos para poder posteriormente trabajar con el resto de transacciones que
necesitan de un banco, como la contabilidad, gestión de cobros, etc.,

Accederemos al esquema de carpetas,

Finanzas → [Link] → Bancos → Datos Maestros → Maestro de
bancos → Crear
O directamente con la transacción FI01
Tanto si accedemos por la estructura de carpetas como si lo hacemos directamente poniendo
la transacción en la parte superior y pulsando “intro” para que Sap ejecute la misma, nos
aparecerá la siguiente pantalla.
En esta primera pantalla que nos aparece dentro de la creación de bancos, es la que tenemos
en la parte superior de esta página, en la que tenemos que determinar el país del banco. Si no
conocemos el código del país, podemos utilizar el “Matchcode” para que nos facilite una lista
de países y podamos seleccionar el que nos interesa (España – ES).

Seguidamente damos un “código” personalizado al banco que estamos creando y pulsamos

“validar”.
En la pantalla anterior tan solo tenemos que poner los datos correspondientes a la entidad
financiera y sucursal que queremos crear.

Después de rellenar estos datos, podemos acceder a la pantalla que nos va a permitir si es
necesario ampliar la información.
Icono que nos permite mostrar otro formulario para completar la información del banco que
estamos creando.
Al activar el icono nos aparece el formulario siguiente,
Si realizamos cambios en la pantalla anterior pulsaremos aceptar, sino podemos cancelar.

Display Subtotal and Total in ABAP ALV Grid

Use below steps to calculate totals in ABAP ALV.

1. Build field catalog and set the field DO_SUM of field catalog to ‘X’ for the field
for which you want calculate the totals.
2. Pass field catalog to function module ‘REUSE_ALV_GRID_DISPLAY’.
TYPE-POOLS: slis. " SLIS contains all the ALV data types

*&---------------------------------------------------------------------*
*& Data Declaration
*&---------------------------------------------------------------------*
DATA: it_sbook TYPE TABLE OF sbook.
DATA: it_fieldcat TYPE slis_t_fieldcat_alv,
 wa_fieldcat TYPE slis_fieldcat_alv.
*&---------------------------------------------------------------------*
*& START-OF-SELECTION
*&---------------------------------------------------------------------*
START-OF-SELECTION.

*Fetch data from the database

SELECT * FROM sbook INTO TABLE it_sbook.

*Build field catalog

wa_fieldcat-fieldname = 'CARRID'. " Fieldname in the data table
wa_fieldcat-seltext_m = 'Airline'. " Column description in the output
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'CONNID'.
wa_fieldcat-seltext_m = 'Con. No.'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'FLDATE'.
wa_fieldcat-seltext_m = 'Date'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'BOOKID'.
wa_fieldcat-seltext_m = 'Book. ID'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'PASSNAME'.
wa_fieldcat-seltext_m = 'Passenger Name'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'LOCCURAM'.
wa_fieldcat-seltext_m = 'Price'.
*Calculate Total for Price
wa_fieldcat-do_sum = 'X'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'LOCCURKEY'.
wa_fieldcat-seltext_m = 'Currency'.
APPEND wa_fieldcat TO it_fieldcat.

*Pass data and field catalog to ALV function module to display ALV list
CALL FUNCTION 'REUSE_ALV_GRID_DISPLAY'
EXPORTING
it_fieldcat = it_fieldcat
TABLES
t_outtab = it_sbook
EXCEPTIONS

program_error = 1

OTHERS = 2.
Output

Subtotal in ABAP ALV

To calculate subtotal in ALV, build sort catalog and set the field SUBTOT of sort catalog to
‘X’.

TYPE-POOLS: slis. " SLIS contains all the ALV data types

*&---------------------------------------------------------------------*
*& Data Declaration
*&---------------------------------------------------------------------*
DATA: it_sbook TYPE TABLE OF sbook.
DATA: it_fieldcat TYPE slis_t_fieldcat_alv,
wa_fieldcat TYPE slis_fieldcat_alv,
it_sort TYPE slis_t_sortinfo_alv,
wa_sort TYPE slis_sortinfo_alv..
*&---------------------------------------------------------------------*
*& START-OF-SELECTION
*&---------------------------------------------------------------------*
START-OF-SELECTION.

*Fetch data from the database

SELECT * FROM sbook INTO TABLE it_sbook.

*Build field catalog

wa_fieldcat-fieldname = 'CARRID'. " Fieldname in the data table
wa_fieldcat-seltext_m = 'Airline'. " Column description in the output
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'CONNID'.
wa_fieldcat-seltext_m = 'Con. No.'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'FLDATE'.
wa_fieldcat-seltext_m = 'Date'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'BOOKID'.
wa_fieldcat-seltext_m = 'Book. ID'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'PASSNAME'.
wa_fieldcat-seltext_m = 'Passenger Name'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'LOCCURAM'.
wa_fieldcat-seltext_m = 'Price'.
wa_fieldcat-do_sum = 'X'.
APPEND wa_fieldcat TO it_fieldcat.

wa_fieldcat-fieldname = 'LOCCURKEY'.
wa_fieldcat-seltext_m = 'Currency'.
APPEND wa_fieldcat TO it_fieldcat.
*Build sort catalog
wa_sort-spos = 1.
wa_sort-fieldname = 'CARRID'.
wa_sort-up = 'X'.
wa_sort-subtot = 'X'.
APPEND wa_sort TO it_sort.

*Pass data and field catalog to ALV function module to display ALV list
 CALL FUNCTION 'REUSE_ALV_GRID_DISPLAY'
EXPORTING
it_fieldcat = it_fieldcat
it_sort = it_sort
TABLES
t_outtab = it_sbook
EXCEPTIONS
program_error = 1
OTHERS = 2.

Output
If you want to calculate subtotals for more fields, just add a record in sort field catalog for
each field.

*Build sort catalog

wa_sort-spos = 1.
wa_sort-fieldname = 'CARRID'.
wa_sort-up = 'X'.
wa_sort-subtot = 'X'.
APPEND wa_sort TO it_sort.

wa_sort-spos = 2.
wa_sort-fieldname = 'CONNID'.
wa_sort-up = 'X'.
wa_sort-subtot = 'X'.
APPEND wa_sort TO it_sort.

Output
ALV con botones estandar y propios
612 Views
Follow
RSS Feed

Buenos dias,

estoy haciendo un ALV OO en el que tengo la botonera estandar y botones

agregados por mi, agregados con un metodo asignado al evento toolbar de la
clase cl_gui_alv_grid tal que asi

METHOD toolbar2.
DATA l_function LIKE e_toolbar-function.
**Mostrar registro de IT0768
l_function = 'V_768'.
CLEAR e_toolbar.
e_toolbar-function = l_function.
e_toolbar-icon = icon_system_possible_entries.
e_toolbar-disabled = space.
e_toolbar-text = text-022.
e_toolbar-quickinfo = ''.
APPEND e_toolbar TO e_object->mt_toolbar.

**Mostrar registro de IT2001

l_function = 'V_2001'.
CLEAR e_toolbar.
e_toolbar-function = l_function.
e_toolbar-icon = icon_system_possible_entries.
e_toolbar-disabled = space.
e_toolbar-text = text-023.
e_toolbar-quickinfo = ''.
APPEND e_toolbar TO e_object->mt_toolbar.

** Bloquear registro
l_function = 'V_BLOQ'.
CLEAR e_toolbar.
e_toolbar-function = l_function.
e_toolbar-icon = icon_locked.
e_toolbar-disabled = space.
e_toolbar-quickinfo = ''.
APPEND e_toolbar TO e_object->mt_toolbar.

** Desbloquear resgistro
l_function = 'V_DBLOQ'.
CLEAR e_toolbar.
e_toolbar-function = l_function.
e_toolbar-icon = icon_unlocked.
e_toolbar-disabled = space.
e_toolbar-quickinfo = ''.
APPEND e_toolbar TO e_object->mt_toolbar.
e_interactive = 'X'.
ENDMETHOD. "toolbar

la cuestion es que cuando quiero controlar las acciones asociadas a mis botones
hago una redifinicion del metodo dispatch

y pierdo la funcionalidad de los botones estandar.

Como puedo recuperar esa funcionalidad y a la vez poder implementar la de mis

botones.

Un saludo
*----- Sample Progam -----*
*----------------------------------------------------------------------*
***INCLUDE YRVR058_DEST_WISE_SUMMARY_DF01 .
*----------------------------------------------------------------------*
*&---------------------------------------------------------------------*
*& Form DISPLAY_DATA
*&---------------------------------------------------------------------*
* text *-- Rajesh Vasudeva
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM DISPLAY_DATA .
IF ITAB[] IS NOT INITIAL.
PERFORM F_APPEND_BLOCK.
ELSE.
MESSAGE 'Data not found for the selection
criteria' TYPE 'S'.
LEAVE LIST-PROCESSING.
ENDIF.
ENDFORM. " display_data
*&---------------------------------------------------------------------*
*& Form f_append_block
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM F_APPEND_BLOCK .
DATA : L_WA_SORT TYPE SLIS_SORTINFO_ALV, "For
sort
L_WA_EVENTS TYPE SLIS_ALV_EVENT. "For
events

* Event (Top of List)

CLEAR L_WA_EVENTS.
L_WA_EVENTS-NAME = SLIS_EV_TOP_OF_LIST.
L_WA_EVENTS-FORM = C_TOPOFPAGE.
APPEND L_WA_EVENTS TO I_EVENTS_PART.

* Event (Top of Page)

CLEAR L_WA_EVENTS.
L_WA_EVENTS-NAME = SLIS_EV_TOP_OF_PAGE.
L_WA_EVENTS-FORM = 'F_DISPLAY_HEADER_PARTA'(031).
"f_display_header_part
APPEND L_WA_EVENTS TO I_EVENTS_PART.

* Event (End of List)

CLEAR L_WA_EVENTS.
L_WA_EVENTS-NAME = SLIS_EV_END_OF_LIST.
L_WA_EVENTS-FORM = C_END_OF_LIST.
APPEND L_WA_EVENTS TO I_EVENTS_PART.

* Set Layout Zebra

STRUCT_LAYOUT-ZEBRA = 'X'.
STRUCT_LAYOUT-NUMC_SUM = 'X'.
 STRUCT_LAYOUT-TOTALS_TEXT = 'TOTAL:'(032).

* set field catalog

PERFORM F_FIELD_CATALOG_PART.
ASSIGN ITAB[] TO <F_OUTTAB>.
V_PART = 'A'. "initiating list is A
PERFORM F_DISPLAY_BLOCK USING STRUCT_LAYOUT
I_FIELD_CAT_PART[]
C_TAB
I_EVENTS_PART[]
I_SORT_PART[].

ENDFORM. " f_append_block

*&---------------------------------------------------------------------*
*& Form f_field_catalog_part
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM F_FIELD_CATALOG_PART .
REFRESH I_FIELD_CAT_PART.
CLEAR I_FIELD_CAT_PART.
PERFORM F_CREATE_CATALOG USING :
*Month
C_TAB 'MONTH' 'MONTH' SPACE 'L' 7
I_FIELD_CAT_PART[],
*OBD
*C_TAB 'VBELN' 'Delivery' SPACE 'L' 12
I_FIELD_CAT_PART[],
*DATE
C_TAB 'WADAT_IST' 'Date' SPACE 'L' 10
I_FIELD_CAT_PART[],
*Destination
C_TAB 'CITY1' 'Destination' SPACE 'L' 25
I_FIELD_CAT_PART[],
*Qty By Road
C_TAB 'NTGEW_ROAD' 'Road Quantity' SPACE 'R' 16
I_FIELD_CAT_PART[],
*Rail Qty
C_TAB 'NTGEW_RAIL' 'Rail Quantity' SPACE 'R' 16 I_FIELD_CAT_PART[],
*Total Qty C_TAB 'TOT' 'Total Quantity' SPACE 'R' 16
I_FIELD_CAT_PART[], *RR/Trk No.
C_TAB 'EXTI2' 'Truck/RR No.' SPACE 'L' 17 I_FIELD_CAT_PART[].

ENDFORM. " f_field_catalog_part

*&---------------------------------------------------------------------*
*& Form f_DISPLAY_block
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* -->P_STRUCT_LAYOUT text
* -->P_I_FIELD_CAT_PART[] text
* -->P_C_TAB text
* -->P_I_EVENTS_PART[] text
* -->P_I_SORT_PART[] text
*----------------------------------------------------------------------*
FORM F_DISPLAY_BLOCK USING FP_LAYOUT TYPE
SLIS_LAYOUT_ALV
FP_I_FCAT TYPE
SLIS_T_FIELDCAT_ALV
VALUE(FP_TABNAME) TYPE
ANY
FP_I_EVENTS TYPE
SLIS_T_EVENT
FP_I_SORT TYPE
SLIS_T_SORTINFO_ALV.
DATA: V_REPID TYPE SYREPID,
"current Program id
C_SAVE TYPE CHAR1 VALUE 'A'.
"variant save
V_REPID = SY-REPID.

CALL FUNCTION 'REUSE_ALV_LIST_DISPLAY'

*CALL FUNCTION 'REUSE_ALV_GRID_DISPLAY'
EXPORTING
I_CALLBACK_PROGRAM = V_REPID
IS_LAYOUT = FP_LAYOUT
IT_FIELDCAT = FP_I_FCAT[]
IT_SORT = FP_I_SORT[]
I_SAVE = C_SAVE "variant
save
IT_EVENTS = FP_I_EVENTS[]
TABLES
T_OUTTAB = <F_OUTTAB>
EXCEPTIONS
PROGRAM_ERROR = 1
OTHERS = 2.

IF SY-SUBRC <> 0.
MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.
ENDFORM. " f_DISPLAY_block
*&---------------------------------------------------------------------*
*& Form f_create_catalog
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* -->P_C_TAB text
* -->P_0085 text
* -->P_0086 text
* -->P_SPACE text
* -->P_0088 text
* -->P_5 text
* -->P_I_FIELD_CAT_PART[] text
*----------------------------------------------------------------------*
FORM F_CREATE_CATALOG USING FP_I_TABNAME TYPE
SLIS_TABNAME
FP_I_FIELDNAME TYPE SLIS_FIELDNAME
FP_I_SELTEXT TYPE
SCRTEXT_L
FP_I_DOSUM TYPE
CHAR1
FP_I_JUST TYPE C
FP_I_OUTPUTLEN TYPE
OUTPUTLEN
FP_I_FCAT TYPE
SLIS_T_FIELDCAT_ALV.

* Record for field catalog

DATA: L_REC_FCAT TYPE SLIS_FIELDCAT_ALV.

L_REC_FCAT-TABNAME = FP_I_TABNAME.
L_REC_FCAT-FIELDNAME = FP_I_FIELDNAME.
L_REC_FCAT-SELTEXT_L = FP_I_SELTEXT.
L_REC_FCAT-DO_SUM = 'X'.
*l_rec_fcat-do_sum = ' '.
L_REC_FCAT-JUST = FP_I_JUST.
L_REC_FCAT-OUTPUTLEN = FP_I_OUTPUTLEN.
L_REC_FCAT-DECIMALS_OUT = '2'.
L_REC_FCAT-KEY = '1'.

APPEND L_REC_FCAT TO FP_I_FCAT.

ENDFORM. " f_create_catalog

***********************************************************************
* Subroutines for Headings
***********************************************************************

*&---------------------------------------------------------------------*
*& Form f_display_header_partA
*&---------------------------------------------------------------------*
* Display header for report for Part A
*----------------------------------------------------------------------*
*&---------------------------------------------------------------------*
*& Form top_of_page
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
* --> p1 text
* <-- p2 text
*----------------------------------------------------------------------*
FORM TOP_OF_PAGE .
SKIP 1.
WRITE:/25 ' Name of Company ',80 'RUN DATE' ,
SY-DATUM.
* SKIP 1.
* WRITE:/60 'RUN DATE' , SY-DATUM.
SKIP 1.
DATA: YR(4) TYPE N,
FIN_PRD(10) TYPE C.
IF S_DTABF-LOW+4(2) LT '04'.
YR = S_DTABF-LOW+0(4) - 1.
CONCATENATE YR '-' S_DTABF-LOW+2(2) INTO FIN_PRD.
ELSE.
YR = S_DTABF-LOW+0(4) + 1.
 CONCATENATE S_DTABF-LOW+0(4) '-' YR+2(2) INTO
FIN_PRD.
ENDIF.
WRITE:/5 'DETAILS OF THE MONTH/DATE WISE DESPATCHES
MADE BY ROAD/RAIL DURING THE YEAR ' , FIN_PRD .
SKIP 1.
* WRITE :/ 'SALES OFFICE : ' , P_SALES,' ' , RNAME.
* SKIP 1.
ENDFORM. " DISPLAY_DATA