C_ABAPD_2507 questions and answers

In SAP S/4HANA Cloud, public edition , database tables are only extendable if SAP has explicitly enabled extensibility for them via metadata. This is a strict limitation in the ABAP Cloud model to ensure upgrade-stability and isolation of extensions from SAP-owned objects.

Key facts:

The annotation @AbapCatalog.dataMaintenance : #RESTRICTED implies that this table is not editable or extensible by default.

The table resides in a delivered component and unless SAP marks it as extensible , customers cannot add
fields like zz_countrycode.

Even if the table is in an ABAP Cloud-compliant software component, extensibility must be explicitly enabled by SAP.

Therefore, Option B is the only correct and valid answer.

Incorrect options:

Option A and D are wrong because extensibility is not determined by the software component type alone.

Option C is wrong because customers cannot enable extensibility for SAP-delivered tables; it must be pre-
approved by SAP.

References:
ABAP Extension Guidelines for SAP S/4HANA Cloud (ABAP Extension.pdf, section 2.3 ?
Extensibility Enablement and Restrictions in Tier 1)

In ABAP Cloud/RAP examples, test classes are created inside the development object (e.g., inside the behavior implementation) and are marked FOR TESTING--these are local classes (they live in the program/class include, not as separate global repository classes). The guides show creating test classes under the Test Classes tab and referencing the Local Types section of the implementation (friends etc.), i.e., local to the program/object.

This contrasts with global classes that exist as standalone repository objects; the RAP test patterns explicitly model the former (local) for unit tests within the object's context.

from_mixed converts a mixed-case string into uppercase with a chosen separator between words.

Given input 'LorelpsumFactum', the function splits at uppercase letters, uppercases the parts, and joins them with _.

Output: LORE_IPSUM_FACTUM. condense only removes extra spaces, to_upper only changes case, and to_mixed does the reverse of from_mixed.

References:
ABAP Keyword Documentation ?String Functions (from_mixed, to_mixed) .

p (packed number) is a complete type , as it includes decimal places and precision definition.

d (date), c (character), n (numeric text) are incomplete types ; they require length specification.
References:
ABAP Keyword Documentation ?Predefined ABAP Types .

In ABAP, when calculating the difference between two date fields (type DATS) , the result is directly a type i (integer) representing the difference in days.

Statement B is correct:

data(gv_diff_days) = gs_booking-flight_date - gs_booking-order_date.

This directly subtracts two DATS fields, resulting in an integer value for the number of days difference. No conversion is necessary.

Statements A and D are incorrect because the conv d( ... ) attempts to convert the result back to a DATS type, which is invalid since the result is an integer (number of days), not a date.

Statement C is syntactically correct but would produce the negative of the desired value (flight date - order date). It is semantically incorrect for the use case.

This approach is consistent with ABAP for Cloud Development , which requires explicit typing , and ABAP language version strict mode , where automatic type inference is restricted.

References:
ABAP Language Documentation ?DATS arithmetic and date operations section
consistent
with ABAP Cloud version restrictions.

RAP and ABAP Cloud emphasize expression-based coding , and REDUCE is a key reduction expression.
The code above defines an accumulator (h_structure_variable) and iterates over an internal table (source_itab) with FOR ... IN ..., so a loop over the source table is created (D). In each iteration, fields are accumulated and, when the expression finishes, the final accumulator value is returned and assigned to structure_variable. With compatible structured types, components are copied name-by-name (C).

In ABAP Cloud, the language is explicitly described as "aligned and extended to support RAP ... The application developer uses typed APIs ... and benefits from static code checks." This underpins the use of typed, expression-based constructs like REDUCE for safe, declarative logic.

Behavior Definition (BDEF) is where read-only, mandatory, and transactional rules are enforced across all
RAP applications.

Projection view # restricts fields per app, not globally.

Metadata extension # UI annotations only.

Service definition # defines exposure, not behavior.

Therefore, setting field read-only in the behavior definition enforces it globally across all RAP BO usages.

References:
RAP Development Guide ?Behavior Definitions and Field Control .

The situation described is a classic one-to-many relationship from department#employees, with "including none at all" implying 0.. * employees per department. In SAP modeling, cardinalities are expressed with ranges like [0..*] to denote zero-to-many. This notation is used consistently in ABAP Cloud/RAP documentation for compositions/associations as well (e.g., tables/structures or nested lists), where [0..*]
means "any number (including none)".

Therefore, the correct foreign-key cardinality that matches "a department may have any number of employees (including none)" is [0..*,1] (many employees per one department). The same documentation set also uses "pure foreign key" associations with multiplicities to model such relationships.

The requirement is:

Retrieve all carriers from T_CARRIER

Include them even if no corresponding connections exist in T_CONNECTIONS.

Evaluation of each join type:

A-. INNER JOIN:Only returns rows where a carrier has at least one matching connection .# Incorrect, since carriers without connections would be excluded.

B-. LEFT OUTER JOIN (correct):Returns all rows from the left table (T_CARRIER) , and connections if they exist.Missing connections are represented with NULL.# Correct answer.

C-. LEFT INNER JOIN:This is syntactically invalid in ABAP SQL. INNER JOIN and LEFT OUTER JOIN are separate join types, not combined.# Incorrect.

D-. RIGHT OUTER JOIN (correct):Equivalent to LEFT OUTER JOIN when the tables are reversed.
Returns all rows from T_CARRIER , whether or not connections exist.# Correct answer.

Thus, LEFT OUTER JOIN and RIGHT OUTER JOIN are the valid solutions to retrieve all carriers regardless of connections.

References:
ABAP CDS Development Guide ?section on SQL Joins
ABAP SQL join semantics for INNER,
LEFT OUTER, and RIGHT OUTER joins.

Tier 1 (cloud-ready) extensions "follow ABAP Cloud rules and hence by default can only access the public SAP interfaces (objects released for cloud development )." This directly supports using released APIs (C) and cloud-enabled/released technologies (D).

The three-tier extensibility model separates safe cloud extensions (Tier 1) from classic code; Tier 2 wrappers exist only to mitigate missing public APIs , but they are not the recommended pattern for S /4HANA Cloud public-edition extensions (therefore B is not a rule).

In S/4HANA Cloud, object changes are not allowed ; instead, customers must use predefined extension points (E)--for example, whitelisted extension includes , released BAdIs, or CDS extension points exposed for cloud usage--consistent with the ABAP Cloud principle of public, released artifacts only. (This is the prescribed approach in the ABAP Cloud extensibility guidance that accompanies the three-tier model.)

In ABAP, structure component access uses the hyphen (-): structure-component. The other tokens are used for different purposes: -> for object reference attributes, => for static components, and / is not a field
selector in ABAP.

ABAP Cloud stresses typed APIs and static checks , ensuring misuse of component selectors is caught early; correct structure access with - is part of the enforced style.

In a CDS view entity defined AS SELECT FROM , the association ON condition must use the source aliases defined in the FROM clause.

$projection is used in projection views (AS PROJECTION ON ...), not in a basic select view entity.
Therefore, options using $projection (B, C) are invalid here.

Using global names (Z_SOURCE1, Z_SOURCE2) in the ON (A) ignores the declared aliases and is not the recommended/valid form within the view definition.

The correct ON clause uses the aliases_Source1 and Source2 with the matching key fields:ON _Source1.carrier_id = Source2.carrier_id (D).

This aligns with CDS modeling rules in RAP: use aliases consistently and model associations with precise ON conditions based on keys.

References:
ABAP CDS Development--Associations & ON conditions
RAP Data Modeling.

Encapsulation in ABAP OO and ABAP Cloud ensures that internal object details are hidden from outside consumers.

A-. Attributes can be changed through public methods # # Correct, because controlled access is provided through getter/setter or other methods.
B-. Attributes can be changed by the client program directly # # Incorrect, this violates encapsulation.
C-. Attributes cannot be changed # # Incorrect, they can be changed, but only via allowed mechanisms.
D-. Attributes can only be changed by the class itself # # Correct, ensuring business logic consistency.

This aligns with RAP behavior definitions (BDEF) where internal attributes are encapsulated and only manipulated through behavior implementation methods.

References:
ABAP Objects Programming Guide Encapsulation Principles .

A # Recommended to define attributes for message placeholders.

C # Inheriting from cx_static_check enforces compile-time checks to ensure exceptions are handled.

E # Implementing if_t100_message allows integration with message classes.

B # Misleading, design-time warning is about handling, not raising.

D # Not a recommended practice in ABAP Cloud (system classes are not extendable).

References:
ABAP Objects Guide ?Defining Exception Classes .

Clean-core development requires extending only through released APIs and extension points; direct modifications or unreleased calls break upgrade safety.