@linkup-ai/abap-ai 2.0.0

package/dist/knowledge/abap/rap-unmanaged.md

@@ -0,0 +1,468 @@
+# RAP Unmanaged BO — wrapping BAPIs, FMs, legacy code
+
+## When to Use
+
+- Wrapping existing BAPIs/FMs as RAP BO (legacy modernization)
+- Complex save logic that managed BO cannot handle
+- Custom persistence (non-standard DB operations)
+- Integration with external systems during save
+
+## BDEF — Unmanaged
+
+```abap
+unmanaged implementation in class ZBP_I_ORDER unique;
+strict ( 2 );
+
+define behavior for ZI_Order alias Order
+lock master
+authorization master ( instance )
+etag master LocalLastChangedAt
+{
+  create;
+  update;
+  delete;
+
+  field ( readonly ) OrderID;
+  field ( readonly ) CreatedBy, CreatedAt, LastChangedBy, LastChangedAt, LocalLastChangedAt;
+  field ( mandatory ) CustomerID;
+
+  action confirm result [1] $self;
+
+  validation validateCustomer on save { create; update; field CustomerID; }
+  determination setOrderID on modify { create; }
+
+  mapping for ztab_order corresponding;
+  association _Item { create; }
+}
+
+define behavior for ZI_OrderItem alias Item
+lock dependent by _Order
+authorization dependent by _Order
+{
+  update;
+  delete;
+
+  field ( readonly ) OrderID, ItemID;
+
+  mapping for ztab_order_item corresponding;
+  association _Order;
+}
+```
+
+Key difference from managed: `unmanaged` keyword. Developer must implement ALL CRUD operations.
+
+## Handler Class — CREATE
+
+```abap
+CLASS lhc_order DEFINITION INHERITING FROM cl_abap_behavior_handler.
+  PRIVATE SECTION.
+    METHODS create FOR MODIFY IMPORTING entities FOR CREATE Order.
+    METHODS update FOR MODIFY IMPORTING entities FOR UPDATE Order.
+    METHODS delete FOR MODIFY IMPORTING keys FOR DELETE Order.
+    METHODS read FOR READ IMPORTING keys FOR READ Order RESULT result.
+    METHODS lock FOR LOCK IMPORTING keys FOR LOCK Order.
+    METHODS get_instance_authorizations FOR INSTANCE AUTHORIZATION
+      IMPORTING keys REQUEST requested_authorizations FOR Order RESULT result.
+ENDCLASS.
+
+CLASS lhc_order IMPLEMENTATION.
+
+  METHOD create.
+    DATA lt_buffer TYPE STANDARD TABLE OF ztab_order.
+
+    LOOP AT entities ASSIGNING FIELD-SYMBOL(<entity>).
+      " Generate key
+      DATA(lv_id) = get_next_id( ).
+
+      " Prepare buffer record
+      DATA(ls_order) = CORRESPONDING ztab_order( <entity> MAPPING FROM ENTITY ).
+      ls_order-order_id = lv_id.
+      ls_order-created_by = cl_abap_context_info=>get_user_technical_name( ).
+      GET TIME STAMP FIELD ls_order-created_at.
+      ls_order-last_changed_by = ls_order-created_by.
+      GET TIME STAMP FIELD ls_order-last_changed_at.
+      GET TIME STAMP FIELD ls_order-local_last_changed_at.
+
+      APPEND ls_order TO lt_buffer.
+
+      " Return mapped key
+      INSERT VALUE #(
+        %cid     = <entity>-%cid
+        order_id = lv_id
+      ) INTO TABLE mapped-order.
+    ENDLOOP.
+
+    " Buffer — actual DB insert happens in saver class
+    INSERT ztab_order FROM TABLE @lt_buffer.
+  ENDMETHOD.
+
+  METHOD update.
+    DATA lt_buffer TYPE STANDARD TABLE OF ztab_order.
+
+    LOOP AT entities ASSIGNING FIELD-SYMBOL(<entity>).
+      " Read current data
+      SELECT SINGLE * FROM ztab_order
+        WHERE order_id = @<entity>-OrderID
+        INTO @DATA(ls_current).
+
+      " Apply only changed fields (using %control)
+      IF <entity>-%control-CustomerID = if_abap_behv=>mk-on.
+        ls_current-customer_id = <entity>-CustomerID.
+      ENDIF.
+      IF <entity>-%control-Description = if_abap_behv=>mk-on.
+        ls_current-description = <entity>-Description.
+      ENDIF.
+      IF <entity>-%control-Status = if_abap_behv=>mk-on.
+        ls_current-status = <entity>-Status.
+      ENDIF.
+
+      ls_current-last_changed_by = cl_abap_context_info=>get_user_technical_name( ).
+      GET TIME STAMP FIELD ls_current-last_changed_at.
+      GET TIME STAMP FIELD ls_current-local_last_changed_at.
+
+      UPDATE ztab_order FROM @ls_current.
+    ENDLOOP.
+  ENDMETHOD.
+
+  METHOD delete.
+    LOOP AT keys ASSIGNING FIELD-SYMBOL(<key>).
+      DELETE FROM ztab_order WHERE order_id = @<key>-OrderID.
+      DELETE FROM ztab_order_item WHERE order_id = @<key>-OrderID.
+    ENDLOOP.
+  ENDMETHOD.
+
+  METHOD read.
+    SELECT * FROM ztab_order
+      FOR ALL ENTRIES IN @keys
+      WHERE order_id = @keys-OrderID
+      INTO TABLE @DATA(lt_orders).
+
+    result = CORRESPONDING #( lt_orders MAPPING TO ENTITY ).
+  ENDMETHOD.
+
+  METHOD lock.
+    " Enqueue lock
+    LOOP AT keys ASSIGNING FIELD-SYMBOL(<key>).
+      TRY.
+          " Call lock object
+          NEW zcl_order_lock( )->lock( iv_order_id = <key>-OrderID ).
+        CATCH zcx_lock_error.
+          INSERT VALUE #( %tky = <key>-%tky ) INTO TABLE failed-order.
+          INSERT VALUE #( %tky = <key>-%tky
+            %msg = new_message_with_text(
+              severity = if_abap_behv_message=>severity-error
+              text = |Order { <key>-OrderID } is locked by another user| ) )
+            INTO TABLE reported-order.
+      ENDTRY.
+    ENDLOOP.
+  ENDMETHOD.
+
+  METHOD get_instance_authorizations.
+    " Check authorization per instance
+    LOOP AT keys ASSIGNING FIELD-SYMBOL(<key>).
+      INSERT VALUE #(
+        %tky = <key>-%tky
+        %create = if_abap_behv=>auth-allowed
+        %update = if_abap_behv=>auth-allowed
+        %delete = if_abap_behv=>auth-allowed
+      ) INTO TABLE result.
+    ENDLOOP.
+  ENDMETHOD.
+
+ENDCLASS.
+```
+
+## Saver Class — Persist Changes
+
+```abap
+CLASS lsc_order DEFINITION INHERITING FROM cl_abap_behavior_saver.
+  PROTECTED SECTION.
+    METHODS finalize REDEFINITION.
+    METHODS check_before_save REDEFINITION.
+    METHODS save REDEFINITION.
+    METHODS cleanup REDEFINITION.
+    METHODS cleanup_finalize REDEFINITION.
+ENDCLASS.
+
+CLASS lsc_order IMPLEMENTATION.
+  METHOD finalize.
+    " Final calculations before save (optional)
+  ENDMETHOD.
+
+  METHOD check_before_save.
+    " Cross-entity consistency checks (optional)
+    " Set raised_for_messages = abap_true if there are errors to prevent save
+  ENDMETHOD.
+
+  METHOD save.
+    " Persist transactional buffer to database
+    " In simple cases, DB operations are already in handler methods
+    " In complex cases (BAPI wrapping), call BAPI here:
+
+    " Example: BAPI wrapping
+    " CALL FUNCTION 'BAPI_SALESORDER_CREATEFROMDAT2'
+    "   EXPORTING ...
+    "   IMPORTING ...
+    "   TABLES ...
+    " CALL FUNCTION 'BAPI_TRANSACTION_COMMIT'.
+  ENDMETHOD.
+
+  METHOD cleanup.
+    " Clear transactional buffer (called after save or on rollback)
+  ENDMETHOD.
+
+  METHOD cleanup_finalize.
+    " Cleanup after finalize phase (optional)
+  ENDMETHOD.
+ENDCLASS.
+```
+
+## Save Sequence
+
+```
+1. finalize          — final calculations
+2. check_before_save — cross-entity checks
+3. adjust_numbers    — late numbering (if used)
+4. save              — persist to DB / call BAPI
+5. cleanup           — clear buffer
+```
+
+## Wrapping BAPI — Complete Pattern
+
+```abap
+" BDEF:
+unmanaged implementation in class ZBP_I_BAPI_ORDER unique;
+
+define behavior for ZI_BapiOrder alias Order
+lock master
+authorization master ( global )
+{
+  create;
+  update;
+  field ( readonly ) OrderID;
+}
+```
+
+### Buffer Pattern
+
+```abap
+" Global buffer in class (shared between handler and saver)
+CLASS zbp_i_bapi_order DEFINITION PUBLIC ABSTRACT FINAL
+  FOR BEHAVIOR OF ZI_BapiOrder.
+  PUBLIC SECTION.
+    CLASS-DATA: gt_create TYPE STANDARD TABLE OF zs_bapi_order_create,
+                gt_update TYPE STANDARD TABLE OF zs_bapi_order_update.
+ENDCLASS.
+```
+
+### Handler — Buffer Changes
+
+```abap
+METHOD create.
+  LOOP AT entities ASSIGNING FIELD-SYMBOL(<entity>).
+    DATA(ls_create) = VALUE zs_bapi_order_create(
+      cid         = <entity>-%cid
+      customer_id = <entity>-CustomerID
+      material    = <entity>-Material
+      quantity    = <entity>-Quantity ).
+    APPEND ls_create TO zbp_i_bapi_order=>gt_create.
+
+    " Return mapped with temporary CID (real key assigned by BAPI)
+    INSERT VALUE #( %cid = <entity>-%cid ) INTO TABLE mapped-order.
+  ENDLOOP.
+ENDMETHOD.
+
+METHOD update.
+  LOOP AT entities ASSIGNING FIELD-SYMBOL(<entity>).
+    DATA(ls_update) = VALUE zs_bapi_order_update(
+      order_id = <entity>-OrderID ).
+    IF <entity>-%control-Quantity = if_abap_behv=>mk-on.
+      ls_update-quantity = <entity>-Quantity.
+      ls_update-quantity_changed = abap_true.
+    ENDIF.
+    APPEND ls_update TO zbp_i_bapi_order=>gt_update.
+  ENDLOOP.
+ENDMETHOD.
+```
+
+### Saver — Call BAPI
+
+```abap
+METHOD save.
+  " Process creates
+  LOOP AT zbp_i_bapi_order=>gt_create INTO DATA(ls_create).
+    DATA ls_header TYPE bapisdhead.
+    DATA lt_items TYPE TABLE OF bapisditem.
+    DATA lt_return TYPE TABLE OF bapiret2.
+
+    ls_header-doc_type = 'TA'.
+    ls_header-sales_org = '1000'.
+    ls_header-distr_chan = '10'.
+    ls_header-division = '00'.
+    ls_header-sold_to = ls_create-customer_id.
+
+    APPEND VALUE #( material = ls_create-material
+                    target_qty = ls_create-quantity )
+      TO lt_items.
+
+    CALL FUNCTION 'BAPI_SALESORDER_CREATEFROMDAT2'
+      EXPORTING order_header_in = ls_header
+      IMPORTING salesdocument   = DATA(lv_vbeln)
+      TABLES   order_items_in  = lt_items
+               return          = lt_return.
+
+    IF lv_vbeln IS NOT INITIAL.
+      CALL FUNCTION 'BAPI_TRANSACTION_COMMIT'
+        EXPORTING wait = abap_true.
+    ELSE.
+      " Collect errors from lt_return
+      CALL FUNCTION 'BAPI_TRANSACTION_ROLLBACK'.
+    ENDIF.
+  ENDLOOP.
+
+  " Process updates similarly...
+
+  " Clear buffers
+  CLEAR: zbp_i_bapi_order=>gt_create,
+         zbp_i_bapi_order=>gt_update.
+ENDMETHOD.
+
+METHOD cleanup.
+  CLEAR: zbp_i_bapi_order=>gt_create,
+         zbp_i_bapi_order=>gt_update.
+ENDMETHOD.
+```
+
+## Unmanaged with Additional Save (Hybrid)
+
+```abap
+" Managed BO with custom save logic for specific cases
+managed implementation in class ZBP_I_ORDER unique;
+with additional save;
+
+define behavior for ZI_Order alias Order
+persistent table ztab_order
+lock master
+{
+  create; update; delete;
+}
+```
+
+```abap
+" Saver class — additional save runs AFTER managed save
+CLASS lsc_order DEFINITION INHERITING FROM cl_abap_behavior_saver.
+  PROTECTED SECTION.
+    METHODS save_modified REDEFINITION.
+ENDCLASS.
+
+CLASS lsc_order IMPLEMENTATION.
+  METHOD save_modified.
+    " Runs after standard managed save
+    " Use for: calling external systems, sending emails, custom logging
+
+    " Access what was saved:
+    IF create-order IS NOT INITIAL.
+      " New orders were created — notify external system
+      LOOP AT create-order INTO DATA(ls_created).
+        zcl_external_notifier=>notify_creation( ls_created-OrderID ).
+      ENDLOOP.
+    ENDIF.
+
+    IF update-order IS NOT INITIAL.
+      " Orders were updated
+    ENDIF.
+
+    IF delete-order IS NOT INITIAL.
+      " Orders were deleted
+    ENDIF.
+  ENDMETHOD.
+ENDCLASS.
+```
+
+## Unmanaged Query (Custom CDS with IF_RAP_QUERY_PROVIDER)
+
+```abap
+" For CDS custom entities that don't map to a single DB table
+@EndUserText.label: 'Custom Query Entity'
+@ObjectModel.query.implementedBy: 'ABAP:ZCL_ORDER_QUERY'
+define custom entity ZCE_OrderSummary
+{
+  key OrderID     : abap.numc(10);
+      CustomerName : abap.char(40);
+      TotalAmount  : abap.curr(17,2);
+      Currency     : abap.cuky(5);
+      ItemCount    : abap.int4;
+}
+```
+
+```abap
+CLASS zcl_order_query DEFINITION PUBLIC FINAL CREATE PUBLIC.
+  PUBLIC SECTION.
+    INTERFACES if_rap_query_provider.
+ENDCLASS.
+
+CLASS zcl_order_query IMPLEMENTATION.
+  METHOD if_rap_query_provider~select.
+    " Check what was requested
+    DATA(lv_top) = io_request->get_paging( )->get_page_size( ).
+    DATA(lv_skip) = io_request->get_paging( )->get_offset( ).
+    DATA(lt_filter) = io_request->get_filter( )->get_as_ranges( ).
+    DATA(lt_sort) = io_request->get_sort_elements( ).
+    DATA(lt_requested) = io_request->get_requested_elements( ).
+
+    " Build query based on request
+    SELECT o~order_id, c~name AS customer_name,
+           SUM( i~amount ) AS total_amount,
+           o~currency, COUNT(*) AS item_count
+      FROM ztab_order AS o
+      INNER JOIN ztab_customer AS c ON o~customer_id = c~customer_id
+      INNER JOIN ztab_order_item AS i ON o~order_id = i~order_id
+      GROUP BY o~order_id, c~name, o~currency
+      INTO TABLE @DATA(lt_result)
+      UP TO @lv_top ROWS
+      OFFSET @lv_skip.
+
+    " Return data
+    io_response->set_data( lt_result ).
+
+    " Return total count if requested
+    IF io_request->is_total_numb_of_rec_requested( ).
+      io_response->set_total_number_of_records( lines( lt_result ) ).
+    ENDIF.
+  ENDMETHOD.
+ENDCLASS.
+```
+
+## Managed vs Unmanaged vs Unmanaged Query
+
+| Aspect | Managed | Unmanaged | Unmanaged Query |
+|--------|---------|-----------|-----------------|
+| BDEF keyword | `managed` | `unmanaged` | (custom entity) |
+| CRUD | Framework auto | Developer implements | READ only |
+| DB persistence | `persistent table` | Developer manages | No persistence |
+| Create/Update/Delete | Automatic | Handler methods | Not available |
+| Use case | New development | Legacy wrapping | Complex read aggregations |
+| Draft support | Full | Manual | Not available |
+| Complexity | Low | High | Medium |
+
+## Rules
+- Unmanaged: developer MUST implement create, update, delete, read, lock methods
+- Use `CORRESPONDING ... MAPPING FROM ENTITY` / `TO ENTITY` for BDEF↔DB mapping
+- Buffer pattern: store changes in handler, persist in saver
+- BAPI wrapping: BAPI calls go in saver `save` method (not handler)
+- BAPI wrapping: always BAPI_TRANSACTION_COMMIT after successful BAPI call
+- Additional save (`with additional save`): use for managed BO + external system calls
+- Custom entity + `if_rap_query_provider`: for read-only aggregated data
+- `%control` flags: always check before applying field updates
+
+## Anti-Patterns
+| Anti-Pattern | Correct |
+|---|---|
+| DB operations directly in handler without buffer | Buffer in handler, persist in saver |
+| Missing BAPI_TRANSACTION_COMMIT after BAPI | Always COMMIT (or ROLLBACK on error) |
+| BAPI call in handler (before save sequence) | BAPI in saver `save` method |
+| Ignoring `%control` in update | Check each `%control-Field = if_abap_behv=>mk-on` |
+| Missing lock implementation | Implement FOR LOCK method (or use lock object) |
+| Unmanaged when managed would work | Use managed for new development |
+| Static buffer without cleanup | Always CLEAR buffer in `cleanup` method |
+| Custom entity for simple CRUD | Use managed/unmanaged BO instead |

package/dist/knowledge/abap/string-processing.md

@@ -0,0 +1,180 @@
+# String Processing — templates, concatenation, regex, conversion
+
+## String Templates (Preferred)
+
+```abap
+" Basic interpolation
+DATA(lv_msg) = |Order { lv_id } created for { lv_customer }|.
+
+" Expressions inside { }
+DATA(lv_calc) = |Total: { lv_qty * lv_price }|.
+
+" Formatting: WIDTH, ALIGN, PAD
+DATA(lv_padded) = |{ lv_id WIDTH = 10 ALIGN = RIGHT PAD = '0' }|.  " '0000001234'
+
+" Formatting: ALPHA conversion
+DATA(lv_alpha_in) = |{ '1234' ALPHA = IN WIDTH = 10 }|.   " '0000001234'
+DATA(lv_alpha_out) = |{ '0000001234' ALPHA = OUT }|.       " '1234'
+
+" Formatting: DATE
+DATA(lv_date) = |{ sy-datum DATE = USER }|.        " '15.03.2026' (user format)
+DATA(lv_iso) = |{ sy-datum DATE = ISO }|.           " '2026-03-15'
+DATA(lv_raw) = |{ sy-datum DATE = RAW }|.           " '20260315'
+
+" Formatting: TIME
+DATA(lv_time) = |{ sy-uzeit TIME = ISO }|.          " '14:30:00'
+
+" Formatting: TIMESTAMP
+DATA(lv_ts) = |{ lv_tstamp TIMESTAMP = ISO }|.
+
+" Formatting: NUMBER
+DATA(lv_num) = |{ lv_amount NUMBER = USER CURRENCY = 'EUR' }|.
+
+" Formatting: CASE
+DATA(lv_upper) = |{ lv_name CASE = UPPER }|.
+DATA(lv_lower) = |{ lv_name CASE = LOWER }|.
+
+" Newline, tab
+DATA(lv_multi) = |Line 1{ cl_abap_char_utilities=>newline }Line 2|.
+DATA(lv_tab) = |Col1{ cl_abap_char_utilities=>horizontal_tab }Col2|.
+
+" Escape: \|, \{, \}, \\
+DATA(lv_esc) = |Pipe: \| Brace: \{ Backslash: \\|.
+```
+
+## Concatenation
+
+```abap
+" && operator (preferred)
+DATA(lv_full) = lv_first && ` ` && lv_last.
+
+" CONCATENATE (legacy, still valid)
+CONCATENATE lv_first lv_last INTO DATA(lv_name) SEPARATED BY ` `.
+
+" Concatenate lines of internal table
+CONCATENATE LINES OF lt_parts INTO DATA(lv_csv) SEPARATED BY ','.
+
+" Using REDUCE
+DATA(lv_joined) = REDUCE string( INIT s = ``
+  FOR wa IN lt_items
+  NEXT s = COND #( WHEN s IS INITIAL THEN wa-name
+                    ELSE s && |, { wa-name }| ) ).
+```
+
+## String Functions
+
+```abap
+" Length
+DATA(lv_len) = strlen( lv_text ).
+
+" Substring
+DATA(lv_sub) = substring( val = lv_text off = 0 len = 5 ).
+
+" Find position (0-based, -1 if not found)
+DATA(lv_pos) = find( val = lv_text sub = '@' ).
+
+" Count occurrences
+DATA(lv_cnt) = count( val = lv_text sub = ',' ).
+
+" Replace
+DATA(lv_clean) = replace( val = lv_phone sub = '-' with = `` occ = 0 ). " all occurrences
+
+" Shift / trim
+DATA(lv_trimmed) = condense( lv_text ).                    " trim + collapse spaces
+DATA(lv_ltrim) = shift_left( val = lv_text sub = ' ' ).
+DATA(lv_rtrim) = shift_right( val = lv_text sub = ' ' ).
+DATA(lv_cond) = condense( val = lv_text del = ` ` ).       " remove all spaces
+
+" Case conversion
+DATA(lv_up) = to_upper( lv_text ).
+DATA(lv_lo) = to_lower( lv_text ).
+
+" Reverse
+DATA(lv_rev) = reverse( lv_text ).
+
+" Contains / matches
+IF contains( val = lv_text sub = 'SAP' ).
+IF matches( val = lv_email regex = '^\w+@\w+\.\w+$' ).
+```
+
+## Regex (PCRE)
+
+```abap
+" FIND with regex
+FIND REGEX '(\d{4})-(\d{2})-(\d{2})' IN lv_text
+  SUBMATCHES DATA(lv_year) DATA(lv_month) DATA(lv_day).
+
+" FIND ALL OCCURRENCES
+FIND ALL OCCURRENCES OF REGEX '\d+' IN lv_text
+  RESULTS DATA(lt_matches).
+
+" REPLACE with regex
+REPLACE ALL OCCURRENCES OF REGEX '\s+' IN lv_text WITH ` `.
+
+" Match function
+IF matches( val = lv_phone regex = '^\+?\d{10,15}$' ).
+  " Valid phone number
+ENDIF.
+
+" Named groups (PCRE)
+FIND REGEX '(?<year>\d{4})-(?<month>\d{2})' IN lv_text
+  SUBMATCHES DATA(lv_y) DATA(lv_m).
+```
+
+## Type Conversions
+
+```abap
+" String <-> Number
+DATA(lv_str) = CONV string( 12345 ).
+DATA(lv_int) = CONV i( '999' ).
+DATA(lv_dec) = CONV decfloat34( '123.456' ).
+
+" String <-> Date
+DATA(lv_date_str) = |{ sy-datum DATE = ISO }|.    " '2026-03-15'
+" Parse date from string:
+DATA lv_date TYPE sy-datum.
+lv_date = |20260315|.
+
+" NUMC <-> String (with ALPHA)
+DATA(lv_numc) = |{ '1234' ALPHA = IN WIDTH = 10 }|.   " '0000001234'
+DATA(lv_clean2) = |{ lv_numc10 ALPHA = OUT }|.          " '1234'
+
+" xstring (hex) <-> string
+DATA(lv_xstr) = cl_abap_codepage=>convert_to( lv_text ).
+DATA(lv_back) = cl_abap_codepage=>convert_from( lv_xstr ).
+
+" JSON serialization
+DATA(lv_json) = /ui2/cl_json=>serialize( data = ls_structure ).
+/ui2/cl_json=>deserialize( EXPORTING json = lv_json CHANGING data = ls_target ).
+
+" XCO string (Cloud)
+DATA(lv_upper2) = xco_cp=>string( lv_text )->to_upper_case( )->value.
+DATA(lv_split) = xco_cp=>string( lv_csv )->split( ',' )->value.
+```
+
+## Split
+
+```abap
+SPLIT lv_csv AT ',' INTO TABLE DATA(lt_parts).
+SPLIT lv_line AT cl_abap_char_utilities=>horizontal_tab INTO DATA(lv_f1) DATA(lv_f2) DATA(lv_f3).
+```
+
+## Rules
+- String templates `| |` are preferred over CONCATENATE for readability
+- `&&` concatenation for simple joins, `| |` for interpolation
+- `occ = 0` in `replace()` means all occurrences (default is first only)
+- `condense()` trims and collapses internal whitespace
+- `find()` returns -1 if not found (check before using as offset)
+- ALPHA IN/OUT via string templates is the cleanest conversion
+- Use `matches()` for regex validation, `FIND REGEX` for extraction
+
+## Anti-Patterns
+| Anti-Pattern | Correct |
+|---|---|
+| `CONCATENATE a b INTO c SEPARATED BY space` | `c = \|{ a } { b }\|` |
+| Manual padding with SHIFT/OVERLAY | `\|{ val WIDTH = 10 PAD = '0' }\|` |
+| `WRITE lv_date TO lv_str` for date formatting | `\|{ lv_date DATE = ISO }\|` |
+| `strlen( ) - 1` loop for char-by-char | Use `find()`, `replace()`, regex |
+| `TRANSLATE text TO UPPER CASE` | `to_upper( text )` |
+| `SEARCH text FOR pattern` (legacy) | `find( val = text sub = pattern )` |
+| `cl_abap_regex` for simple matches | `matches( val = text regex = pattern )` |