Tipos de datos y sentencias

Ejemplo moderno equivalente al de abajo: SELECT kunnr, name1 FROM kna1 INTO TABLE @DATA(lt_clientes).

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 OF nombre_tabla.

• Con OCCURS se indica cuántas líneas reservar en memoria al principio; no es un máximo, la tabla crece lo que haga falta. 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.:

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  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.
    ENDLOOP.
  ENDIF.

• 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:

  1
  2
  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 OF nombre_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 la memoria inicial, no un máximo: la tabla siempre puede crecer. Lo habitual es poner 0 y dejar que el sistema decida) 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: TYPES 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.

• INCLUDE nombre.
  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:

  1
  2
  3
  4
  * 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 ] [ TYPE tipo ] [ VALUE valor | IS INITIAL ][ DECIMALS num ].
  También para variables locales. Se usa sólo dentro de FORM s (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:

  1
  2
  3
  4
  5
  6
  DATA: BEGIN OF tabla OCCURS 0,
      SIGN(1)   TYPE C,
      OPTION(2) TYPE C,
      LOW       LIKE campo,
      HIGH      LIKE campo.
  DATA: END OF 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:

  1
  2
  3
  4
  * 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:
  

  1
  2
  3
  4
  5
  * 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).

• 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 acceden con <fs>-campo. Con LINE OF se puede dar una tabla interna. No confundir esta sentencia con FIELD-GROUPS.
  Ejemplo:

  1
  2
  3
  4
  5
  6
  7
  8
  9
  * Con esto ya está declarado el campo simbólico
  FIELD-SYMBOLS <mi_simbolo>.
  
  DATA: campo1(2) TYPE C VALUE 'AA',
        campo2(2) TYPE P VALUE 34.
      ......
  ASSIGN campo1 TO <mi_simbolo>. "Aquí <mi_simbolo> es de tipo C y vale 'AA' 
      ...... 	
  ASSIGN campo2 TO <mi_simbolo>. "Ahora <mi_simbolo> 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, CLEAR, REFRESH y FREE sirven también para tablas internas (no son Native SQL, como decía la versión anterior de esta página).

• 3.5. Sentencias de procesamiento de datos: