ABAP Core Part 3: Data Types and Literals

📌 KEY POINTS
✅ Character types: c (fixed length), n (numeric text), string (variable length).
✅ Numbers: i/int8 (integers), p (packed decimals for amounts), decfloat16/34, f (avoid for money).
✅ Date d (YYYYMMDD) and time t (HHMMSS) are character-like — but you can calculate with them.
⚠️ Text literal '…' has type c and trims trailing spaces; string literal … keeps them.

━━━━━━━━━━━━━━━━━━━━
▶ WHERE WE ARE
Part 2 declared variables. Now: which type to use and what happens with literals.

━━━━━━━━━━━━━━━━━━━━
▶ 1. CHARACTER-LIKE TYPES

• c LENGTH n — fixed length, padded with blanks. Most dictionary fields (airline, names) are c.
• n LENGTH n — digits only, leading zeros (e.g. document numbers like '0000004711'). Not for calculations.
• string — variable length, ideal for texts built at runtime.

━━━━━━━━━━━━━━━━━━━━
▶ 2. NUMERIC TYPES

• i (4-byte integer), int8 (8-byte) — counts, seats, loop counters.
• p LENGTH x DECIMALS y — packed number: exact decimal arithmetic. Use for amounts and quantities (dictionary CURR/QUAN fields are packed).
• decfloat16 / decfloat34 — decimal floating point, exact decimal rounding with large range.
• f — binary floating point: rounding errors. Avoid for money.

━━━━━━━━━━━━━━━━━━━━
▶ 3. DATE AND TIME

• d — 'YYYYMMDD'; lv_date + 30 gives the date 30 days later; difference of two dates = days.
• t — 'HHMMSS'; arithmetic in seconds.
• Timestamps: utclong or timestamp (p) for time zone independent points in time.
• Initial date is '00000000' — check with IS INITIAL.

━━━━━━━━━━━━━━━━━━━━
▶ 4. BYTE TYPES
x and xstring — binary data (files, hashes, attachments).

━━━━━━━━━━━━━━━━━━━━
▶ 5. LITERALS

• Text field literal 'LH' — type c, trailing blanks ignored.
• String literal Hello — type string, keeps trailing blanks.
• Numeric literal 100 — type i; decimals need a text literal: '12.50' converted to p.
• Use string templates |…| for building texts (Part 4).

━━━━━━━━━━━━━━━━━━━━
▶ 6. CHOOSING THE RIGHT TYPE

• Business fields → dictionary data elements (s_carr_id, s_price) — correct length and semantics.
• Amounts → p (with currency field), quantities → p (with unit).
• Counts → i. Texts → string.

💡 TIP: conversions happen automatically between many types (Part 7), but explicit types avoid surprises.

━━━━━━━━━━━━━━━━━━━━
▶ STEP BY STEP
Run the code example and observe: date arithmetic, packed vs float result, c vs string trailing blanks, and numeric text with leading zeros.

✅ CHECKPOINT: you choose types deliberately, especially for amounts and dates.

A custom commission calculation used type f for amounts because "it has more precision". Month-end totals differed from FI postings by a few cents on thousands of documents, and auditors asked for an explanation.
The team switched all amount variables to dictionary-based packed types, rounded explicitly where business rules required, and added a unit test comparing totals with FI. The differences disappeared.

• Using type f for money.
• Calculating with n fields.
• Expecting text literals to keep trailing spaces.
• Generic c fields for business keys instead of dictionary types.
• Not checking dates for IS INITIAL.

• Use dictionary types for business data.
• Packed (p) or decfloat for amounts; never f.
• string for dynamic texts; templates for building them.
• Use date arithmetic directly on type d.
• Be explicit about lengths and decimals in local types.

Questions: "Which data type for amounts?", "Difference between c, n and string?", "Text vs string literal?"
Strong answer: amounts use packed p (or decfloat), never f because of binary rounding; c is fixed-length, n numeric text with leading zeros, string variable length; text literals '…' are type c without trailing blanks, string literals … keep them; dates are type d with day arithmetic. Prefer dictionary types for business fields.