0% found this document useful (0 votes)

2K views

SAP HANA SQL Script Reference en

SAP HANA SQL Script Reference En

Uploaded by

Wpmartins

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

2K views

SAP HANA SQL Script Reference en

SAP HANA SQL Script Reference En

Uploaded by

Wpmartins

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 156

PUBLIC

SAP HANA Platform SPS 11

Document Version: 1.0 2015-11-25

SAP HANA SQLScript Reference

Content

About SAP HANA SQLScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

Backus Naur Form Notation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

What is SQLScript? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3.1

SQLScript Security Considerations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .10

3.2

SQLScript Processing Overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Orchestration-Logic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Declarative-Logic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Datatype Extension. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.1

Scalar Datatypes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4.2

Table Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
CREATE TYPE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
DROP TYPE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Logic Container. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

5.1

Procedures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
CREATE PROCEDURE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
DROP PROCEDURE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
ALTER PROCEDURE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
ALTER PROCEDURE RECOMPILE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Procedure Calls. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29
Procedure Parameters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .33
Procedure Metadata. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.2

User Defined Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42

CREATE FUNCTION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42
DROP FUNCTION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
ALTER FUNCTION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Function Parameters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Function Metadata. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Default Values for Parameters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .51

5.3

Anonymous Block. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .52

Declarative SQLScript Logic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .55

6.1

Table Parameter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56

6.2

Local Table Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

6.3

Table Variable Type Definition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Content

6.4

Binding Table Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6.5

Referencing Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .60

6.6

Column View Parameter Binding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

6.7

HINTS: NO_INLINE and INLINE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Imperative SQLScript Logic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

7.1

Local Scalar Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

7.2

Variable Scope Nesting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

7.3

Control Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Conditionals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
While Loop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
For Loop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Break and Continue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

7.4

Cursors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Define Cursor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Open Cursor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Close Cursor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Fetch Query Results of a Cursor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Attributes of a Cursor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Looping over Result Sets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

7.5

Autonomous Transaction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

7.6

COMMIT and ROLLBACK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

7.7

Dynamic SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
EXEC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
EXECUTE IMMEDIATE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
APPLY_FILTER. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

7.8

Exception Handling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88

DECLARE EXIT HANDLER. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
DECLARE CONDITION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
SIGNAL and RESIGNAL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Exception Handling Examples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

7.9

ARRAY. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
DECLARE ARRAY-TYPED VARIABLE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
SET AN ELEMENT OF AN ARRAY. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
RETURN AN ELEMENT OF AN ARRAY. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
UNNEST. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
ARRAY_AGG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
TRIM_ARRAY. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
CARDINALITY. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
CONCATENATE TWO ARRAYS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

7.10

Index based cell access for table variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102

7.11

Emptiness Check for Table and Table Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

SAP HANA SQLScript Reference

Content

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

7.12

SQL Injection Prevention Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

7.13

Explicit Parallel Execution for DML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

Calculation Engine Plan Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

8.1

Data Source Access Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

CE_COLUMN_TABLE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
CE_JOIN_VIEW. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
CE_OLAP_VIEW. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
CE_CALC_VIEW. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

8.2

Relational Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

CE_JOIN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
CE_LEFT_OUTER_JOIN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
CE_RIGHT_OUTER_JOIN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114
CE_PROJECTION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
CE_CALC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
CE_AGGREGATION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
CE_UNION_ALL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

8.3

Special Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

CE_VERTICAL_UNION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
CE_CONVERSION. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
TRACE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

Procedure and Function Headers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

HANA Spatial Support. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

System Variables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

11.1

::CURRENT_OBJECT_NAME and ::CURRENT_OBJECT_SCHEMA. . . . . . . . . . . . . . . . . . . . . . . . . 132

11.2

::ROWCOUNT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

Supportability. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .135

12.1

M_ACTIVE_PROCEDURES. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

Best Practices for Using SQLScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

13.1

Reduce Complexity of SQL Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

13.2

Identify Common Sub-Expressions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

13.3

Multi-level Aggregation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

13.4

Understand the Costs of Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

13.5

Exploit Underlying Engine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

13.6

Reduce Dependencies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

13.7

Avoid Mixing Calculation Engine Plan Operators and SQL Queries. . . . . . . . . . . . . . . . . . . . . . . . . 141

13.8

Avoid Using Cursors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

13.9

Avoid Using Dynamic SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Content

Developing Applications with SQLScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145

14.1

Handling Temporary Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

14.2

SQL Query for Ranking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

14.3

Calling SQLScript From Clients. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Calling SQLScript from ABAP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Calling SQLScript from Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Calling SQLScript from C#. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Appendix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .152

15.1

Example code snippets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

ins_msg_proc. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

SAP HANA SQLScript Reference

Content

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

About SAP HANA SQLScript

SQLScript is a collection of extensions to the Structured Query Language (SQL). The extensions are:
Data extension, which allows the definition of table types without corresponding tables.
Functional extension, which allows the definition of (side-effect free) functions which can be used to
express and encapsulate complex data flows.
Procedural extension, which provides imperative constructs executed in the context of the database
process.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

About SAP HANA SQLScript

Backus Naur Form Notation

This document uses BNF (Backus Naur Form) which is the notation technique used to define programming
languages. BNF describes the syntax of a grammar using a set of production rules using a set of symbols.
Symbols used in BNF
Table 1:
Symbol

Description

Angle brackets are used to surround the name of a syntactic element (BNF non-terminal) of the
SQL language.

::=

The definition operator is used to provide definitions of the element appeared on the left side of
the operator in a production rule.

[]

Square brackets are used to indicate optional elements in a formula. Optional elements may be
specified or omitted.

{}

Braces group elements in a formula. Repetitive elements (zero or more elements) can be speci
fied within brace symbols.

The alternative operator indicates that the portion of the formula following the bar is an alterna
tive to the portion preceding the bar.

...

The ellipsis indicates that the element may be repeated any number of times. If ellipsis appears
after grouped elements, the grouped elements enclosed with braces are repeated. If ellipsis ap
pears after a single element, only that element is repeated.

Introduces normal English text. This is used when the definition of a syntactic element is not ex
pressed in BNF.

BNF Lowest Terms Representations

Throughout the BNF used in this document each syntax term will be defined to one of the lowest term
representations shown below.
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<letter> ::= a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q |
r | s | t | u | v | w | x | y | z
| A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q |
R | S | T | U | V | W | X | Y | Z
<string_literal> ::= <double_quote><string_content><double_quote> |
<single_quote><string_content><single _quote>
<string_content> = { <letter> | <digit> }...
<identifier> ::= <letter> { <letter> | <digit> }...
<password> ::= [{ <letter> | <digit> }...]
<sign> ::= + | <period> ::= .
<unsigned_integer> ::= <digit>...
<signed_integer> ::= [<sign>] <unsigned_integer>
<signed_numeric_literal> ::= [<sign>] <unsigned_numeric_literal>
<unsigned_numeric_literal> ::= <exact_numeric_literal> |
<approximate_numeric_literal>
<exact_numeric_literal> ::= <unsigned_integer> [<period> [<unsigned_integer>]]
| <period> <unsigned_integer>
<approximate_numeric_literal> ::= <mantissa> E <exponent>
<mantissa> ::= <exact_numeric_literal>

SAP HANA SQLScript Reference

Backus Naur Form Notation

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

<exponent> ::= <signed_integer>

<schema_name> ::= <unicode_name>
<cesu8_restricted_characters> ::= <double_quote> | <dollar_sign> |
<single_quote> | <sign> | <period> | <greater_than_sign> | <lower_than_sign> |
<pipe_sign> | <left_bracket> | <right_bracket> | <left_curly_bracket> |
<right_curly_bracke>t | ( | ) | ! | % | * | , | / | : | ; | = | ? | @ | \ | ^
| `
<unicode_name> ::= !! CESU-8 string excluding any characters listed in
<cesu8_restricted_characters>

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Backus Naur Form Notation

What is SQLScript?

The motivation for SQLScript is to embed data-intensive application logic into the database. As of today,
applications only offload very limited functionality into the database using SQL, most of the application logic is
normally executed in an application server. This has the effect that data to be operated upon needs to be
copied from the database into the application server and vice versa. When executing data intensive logic, this
copying of data can be very expensive in terms of processor and data transfer time. Moreover, when using an
imperative language like ABAP or JAVA for processing data, developers tend to write algorithms which follow a
one tuple at a time semantics (for example looping over rows in a table). However, these algorithms are hard
to optimize and parallelize compared to declarative set-oriented languages such as SQL.
The SAP HANA database is optimized for modern technology trends and takes advantage of modern
hardware, for example, by having data residing in main-memory and allowing massive-parallelization on multicore CPUs. The goal of the SAP HANA database is to optimally support application requirements by leveraging
such hardware. To this end, the SAP HANA database exposes a very sophisticated interface to the application
consisting of many languages. The expressiveness of these languages far exceeds that attainable with
OpenSQL. The set of SQL extensions for the SAP HANA database that allow developers to push data intensive
logic into the database is called SQLScript. Conceptually SQLScript is related to stored procedures as defined
in the SQL standard, but SQLScript is designed to provide superior optimization possibilities. SQLScript
should be used in cases where other modeling constructs of SAP HANA, for example analytic views or
attribute views are not sufficient. For more information on how to best exploit the different view types, see
"Exploit Underlying Engine".
The set of SQL extensions are the key to avoid massive data copies to the application server and for leveraging
sophisticated parallel execution strategies of the database. SQLScript addresses the following problems:
Decomposing an SQL query can only be done using views. However when decomposing complex queries
using views, all intermediate results are visible and must be explicitly typed. Moreover SQL views cannot
be parameterized which limits their reuse. In particular they can only be used like tables and embedded
into other SQL statements.
SQL queries do not have features to express business logic (for example a complex currency conversion).
As a consequence such a business logic cannot be pushed down into the database (even if it is mainly
based on standard aggregations like SUM(Sales), etc.).
An SQL query can only return one result at a time. As a consequence the computation of related result
sets must be split into separate, usually unrelated, queries.
As SQLScript encourages developers to implement algorithms using a set-oriented paradigm and not
using a one tuple at a time paradigm, imperative logic is required, for example by iterative approximation
algorithms. Thus it is possible to mix imperative constructs known from stored procedures with
declarative ones.

Related Information
Exploit Underlying Engine [page 140]

SAP HANA SQLScript Reference

What is SQLScript?

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

3.1

SQLScript Security Considerations

You can develop secure procedures using SQLScript in SAP HANA by observing the following
recommendations.
Using SQLScript, you can read and modify information in the database. In some cases, depending on the
commands and parameters you choose, you can create a situation in which data leakage or data tampering
can occur. To prevent this, SAP recommends using the following practices in all procedures.
Mark each parameter using the keywords IN or OUT. Avoid using the INOUT keyword.
Use the INVOKER keyword when you want the user to have the assigned privileges to start a procedure.
The default keyword, DEFINER, allows only the owner of the procedure to start it.
Mark read-only procedures using READS SQL DATA whenever it is possible. This ensures that the data
and the structure of the database are not altered.

Tip
Another advantage to using READS SQL DATA is that it optimizes performance.
Ensure that the types of parameters and variables are as specific as possible. Avoid using VARCHAR, for
example. By reducing the length of variables you can reduce the risk of injection attacks.
Perform validation on input parameters within the procedure.

Dynamic SQL
In SQLScript you can create dynamic SQL using one of the following commands: EXEC, EXECUTE IMMEDIATE,
and APPLY_FILTER. Although these commands allow the use of variables in SQLScript where they might not
be supported. In these situations you risk injection attacks unless you perform input validation within the
procedure. In some cases injection attacks can occur by way of data from another database table.
To avoid potential vulnerability from injection attacks, consider using the following methods instead of
dynamic SQL:
Use static SQL statements. For example, use the static statement, SELECT instead of EXECUTE
IMMEDIATE and passing the values in the WHERE clause.
Use server-side JavaScript to write this procedure instead of using SQLScript.
Perform validation on input parameters within the procedure using either SQLScript or server-side
JavaScript.

Escape Code
You might need to use some SQL statements that are not supported in SQLScript, for example, the GRANT
statement. In other cases you might want to use the Data Definition Language (DDL) in which some <name>
elements, but not <value> elements, come from user input or another data source. The CREATE TABLE
statement is an example of where this situation can occur. In these cases you can use dynamic SQL to create
an escape from the procedure in the code.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

What is SQLScript?

To avoid potential vulnerability from injection attacks, consider using the folowing methods instead of escape
code:
Use server-side JavaScript to write this procedure instead of using SQLScript.
Perform validation on input parameters within the procedure using either SQLScript or server-side
JavaScript.

Related Information
SAP HANA Security Guide
SAP HANA SQL and System Views Reference

3.2

SQLScript Processing Overview

To better understand the features of SQLScript, and their impact on execution, it can be helpful to understand
how SQLScript is processed in the SAP HANA database.
When a user defines a new procedure, for example using the CREATE PROCEDURE statement, the SAP HANA
database query compiler processes the statement in a similar way to an SQL statement. A step by step
analysis of the process flow follows below:
Parse the statement - Detect and report simple syntactic errors.
Check the statements semantic correctness - Derive types for variables and check their use is consistent.
Optimize the code - Optimization distinguishes between declarative logic shown in the upper branch and
imperative logic shown in the lower branch. We discuss how the SAP HANA database recognizes them
below.
When the procedure starts, the invoke activity can be divided into two phases:
1. Compilation
Code generation - For declarative logic the calculation models are created to represent the dataflow
defined by the SQLScript code. It is optimized further by the calculation engine, when it is instantiated.
For imperative logic the code blocks are translated into L nodes.
The calculation models generated in the previous step are combined into a stacked calculation model.
2. Execution - The execution commences with binding actual parameters to the calculation models. When
the calculation models are instantiated they can be optimized based on concrete input provided.
Optimizations include predicate or projection embedding in the database. Finally the instantiated
calculation model is executed using any of the available parts of the SAP HANA database.
With SQLScript one can implement applications both using imperative orchestration logic and (functional)
declarative logic, and this is also reflected in the way SQLScript processing works for both coding styles.
Imperative logic is executed sequentially and declarative logic is executed by exploiting the internal
architecture of the SAP HANA database utilizing its potential for parallelism.

SAP HANA SQLScript Reference

What is SQLScript?

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

3.2.1 Orchestration-Logic
Orchestration logic is used to implement data flow and control flow logic using imperative language constructs
such as loops and conditionals. The orchestration logic can also execute declarative logic that is defined in the
functional extension by calling the corresponding procedures. In order to achieve an efficient execution on
both levels, the statements are transformed into a dataflow graph to the maximum extent possible. The
compilation step extracts data-flow oriented snippets out of the orchestration logic and maps them to dataflow constructs. The calculation engine serves as execution engine of the resulting dataflow graph. Since the
language L is used as intermediate language for translating SQLScript into a calculation model, the range of
mappings may span the full spectrum from a single internal L-node for a complete SQLScript script in its
simplest form, up to a fully resolved data-flow graph without any imperative code left. Typically, the dataflow
graph provides more opportunities for optimization and thus better performance.
To transform the application logic into a complex data flow graph two prerequisites have to be fulfilled:
All data flow operations have to be side-effect free, that is they must not change any global state either in
the database or in the application logic.
All control flows can be transformed into a static dataflow graph.
In SQLScript the optimizer will transform a sequence of assignments of SQL query result sets to table
variables into parallelizable dataflow constructs. The imperative logic is usually represented as a single node in
the dataflow graph, and thus it will be executed sequentially.

3.2.1.1

Example for Orchestration-Logic

CREATE PROCEDURE orchestrationProc LANGUAGE SQLSCRIPT READS

SQL DATA
AS
BEGIN
DECLARE v_id BIGINT;
DECLARE v_name VARCHAR(30);
DECLARE v_pmnt BIGINT;
DECLARE v_msg VARCHAR(200);
DECLARE CURSOR c_cursor1 (p_payment BIGINT) FOR
SELECT id, name, payment FROM control_tab
WHERE payment > :p_payment
ORDER BY id ASC;
CALL init_proc();
OPEN c_cursor1(250000);
FETCH c_cursor1 INTO v_id, v_name, v_pmnt;
v_msg = :v_name || ' (id ' || :v_id || ') earns ' || :v_pmnt || ' $.';
CALL ins_msg_proc(:v_msg);
CLOSE c_cursor1;
END
This procedure features a number of imperative constructs including the use of a cursor (with associated
state) and local scalar variables with assignments.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

What is SQLScript?

Related Information
ins_msg_proc [page 152]

3.2.2 Declarative-Logic
Declarative logic is used for efficient execution of data-intensive computations. This logic is internally
represented as data flows which can be executed in parallel. As a consequence, operations in a dataflow graph
have to be free of side effects. This means they must not change any global state either in the database or in
the application. The first condition is ensured by only allowing changes on the dataset that is passed as input
to the operator. The second condition is achieved by only allowing a limited subset of language features to
express the logic of the operator. Given these prerequisites, the following kinds of operators are available:
SQL SELECT Statement
Custom operators provided by SAP
Logically each operator represents a node in the data flow graph. Custom operators have to be manually
implemented by SAP.

SAP HANA SQLScript Reference

What is SQLScript?

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Datatype Extension

Besides the built-in scalar SQL datatypes, SQLScript allows you to use and define user-defined types for
tabular values.

4.1

Scalar Datatypes

The SQLScript type system is based on the SQL-92 type system. It supports the following primitive data types:
Table 2:
Numeric types

TINYINT SMALLINT INT BIGINT DECIMAL SMALL

DECIMAL REAL DOUBLE

Character String Types

VARCHAR NVARCHAR

Datetime Types

TIMESTAMP SECONDDATE DATE TIME

Binary Types

VARBINARY

Large Object Types

CLOB NCLOB BLOB

Spatial Types

ST_GEOMETRY

ALPHANUM

Note
This is the same as for SQL statements, excluding the TEXT and SHORTTEXT types.
See SAP HANA SQL and System Views Reference, Data Types section, for further details on scalar types.

4.2

Table Types

SQLScript's datatype extension also allows the definition of table types. These table types are used to define
parameters for a procedure that represent tabular results.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Datatype Extension

4.2.1 CREATE TYPE

Syntax
CREATE TYPE <type_name> AS TABLE (<column_list_definition>)

Syntax Elements
<type_name> ::= [<schema_name>.]<identifier>
Identifies the table type to be created and, optionally, in which schema the creation should take place.
<column_list_definition> ::= <column_elem>[{, <column_elem>}...]
<column_elem> ::= <column_name> <data_type>[<column_store_data_type>]
[<ddic_data_type>]
<column_name> ::= <identifier>
Defines a table column.
<data_type> ::= DATE | TIME | SECONDDATE | TIMESTAMP | TINYINT | SMALLINT |
INTEGER | BIGINT | SMALLDECIMAL | DECIMAL
| REAL | DOUBLE | VARCHAR | NVARCHAR | ALPHANUM | SHORTTEXT |
VARBINARY | BLOB | CLOB | NCLOB | TEXT
<column_store_data_type> ::= CS_ALPHANUM | CS_INT | CS_FIXED | CS_FLOAT |
CS_DOUBLE | CS_DECIMAL_FLOAT | CS_FIXED(p-s, s)
| CS_SDFLOAT | CS_STRING | CS_UNITEDECFLOAT |
CS_DATE | CS_TIME | CS_FIXEDSTRING | CS_RAW
| CS_DAYDATE | CS_SECONDTIME | CS_LONGDATE |
CS_SECONDDATE
<ddic_data_type> ::= DDIC_ACCP | DDIC_ALNM | DDIC_CHAR | DDIC_CDAY | DDIC_CLNT
| DDIC_CUKY | DDIC_CURR | DDIC_D16D
| DDIC_D34D | DDIC_D16R | DDIC_D34R | DDIC_D16S | DDIC_D34S
| DDIC_DATS | DDIC_DAY | DDIC_DEC
| DDIC_FLTP | DDIC_GUID | DDIC_INT1 | DDIC_INT2 | DDIC_INT4
| DDIC_INT8 | DDIC_LANG | DDIC_LCHR
| DDIC_MIN | DDIC_MON | DDIC_LRAW | DDIC_NUMC | DDIC_PREC
| DDIC_QUAN | DDIC_RAW | DDIC_RSTR
| DDIC_SEC | DDIC_SRST | DDIC_SSTR | DDIC_STRG | DDIC_STXT
| DDIC_TIMS | DDIC_UNIT | DDIC_UTCM
| DDIC_UTCL | DDIC_UTCS | DDIC_TEXT | DDIC_VARC | DDIC_WEEK
The available data types. For more information on data types, see Scalar Datatypes [page 14]

Description
The CREATE TYPE statement creates a user-defined type.

SAP HANA SQLScript Reference

Datatype Extension

Logic Container

Syntax Elements
<proc_name> ::= [<schema_name>.]<identifier>
The identifier of the procedure to be created, with optional schema name.
<parameter_clause> ::= <parameter> [{,<parameter>}...]
The input and output parameters of the procedure.
<parameter> ::= [<param_inout>] <param_name> <param_type>
A procedure parameter with associated data type.
<param_inout> ::= IN|OUT|INOUT
Default: IN
Each parameter is marked using the keywords IN/OUT/INOUT. Input and output parameters must be
explicitly typed (i.e. no un-typed tables are supported).
<param_name> ::= <identifier>
The variable name for a parameter.
<param_type> ::= <sql_type> | <table_type> | <table_type_definition>
The input and output parameters of a procedure can have any of the primitive SQL types or a table type.
INOUT parameters can only be of scalar type.
<sql_type> ::= DATE | TIME| TIMESTAMP | SECONDDATE | TINYINT | SMALLINT |
INTEGER | BIGINT | DECIMAL | SMALLDECIMAL | REAL | DOUBLE
| VARCHAR | NVARCHAR | ALPHANUM | VARBINARY | CLOB | NCLOB | BLOB
The data type of the variable. For more information on data types see Data Types in the SAP HANA SQL and
System Views Reference.
<table_type> ::= <identifier>
A table type previously defined with the CREATE TYPE command, see CREATE TYPE [page 15].
<table_type_defintion>
::= TABLE (<column_list_definition>)
<column_list_definition> ::= <column_elem>[{, <column_elem>}...]
<column_elem> ::= <column_name> <data_type>
<column_name> ::= <identifier>
A table type implicitly defined within the signature.
LANGUAGE <lang>
<lang> ::= SQLSCRIPT | R
Default: SQLSCRIPT

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

You use FOR - EACH loops to iterate over all elements in a set of data.
<proc_exit>

::= BREAK ;

Terminates a loop.
<proc_continue> ::= CONTINUE ;
Skips a current loop iteration and continues with the next value.
<proc_signal>

::=

SIGNAL <signal_value> [<set_signal_info>] ;

You use the SIGNAL statement to explicitly raise an exception from within your trigger procedures.
<proc_resignal> ::= RESIGNAL [<signal_value>] [<set_signal_info>] ;
You use the RESIGNAL statement to raise an exception on the action statement in an exception handler. If an
error code is not specified, RESIGNAL will throw the caught exception.
<signal_value>
::= <signal_name> | <sql_error_code>
<signal_name>
::= <identifier>
<sql_error_code> ::= <unsigned_integer>
You can SIGNAL or RESIGNAL a signal name or an SQL error code.
<set_signal_info> ::= SET MESSAGE_TEXT = '<message_string>'
<message_string> ::= <any_character>
You use SET MESSAGE_TEXT to deliver an error message to users when specified error is thrown during
procedure execution.
<proc_sql> ::=

For information on <insert_stmt>, see INSERT in the SAP HANA SQL and System Views Reference.
For information on <delete_stmt>, see DELETE in the SAP HANA SQL and System Views Reference.
For information on <update_stmt>, see UPDATE in the SAP HANA SQL and System Views Reference.
For information on <replace_stmt> and <upsert_stmt>, see REPLACE and UPSERT in the SAP HANA SQL
and System Views Reference.
For information on <truncate_stmt>, see TRUNCATE in the SAP HANA SQL and System Views Reference.
<select_into_stmt> ::= SELECT <select_list> INTO <var_name_list>
<from_clause >
[<where_clause>]
[<group_by_clause>]
[<having_clause>]
[{<set_operator> <subquery>, ... }]
[<order_by_clause>]

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

[<limit>] ;
<var_name_list> ::= <var_name>[{, <var_name>}...]
<var_name>
::= <identifier>
<var_name> is a scalar variable. You can assign selected item value to this scalar variable.
<proc_open> ::= OPEN <cursor_name> [ <open_param_list>] ;
<proc_fetch> ::= FETCH <cursor_name> INTO <column_name_list> ;
<proc_close> ::= CLOSE <cursor_name> ;
Cursor operations
<proc_call> ::= CALL <proc_name> (<param_list>) ;
Calling a procedure; for more information, see CALL - Internal Procedure Call [page 31]
<proc_exec>

::= {EXEC | EXECUTE IMMEDIATE} <proc_expr> ;

You use EXEC to make dynamic SQL calls.

<proc_return> ::= RETURN [<proc_expr>] ;
Return a value from a procedure.

Description
The CREATE PROCEDURE statement creates a procedure using the specified programming language <lang>.

Example
Example - Creating a Procedure
You create an SQLScript procedure with the following definition.
CREATE PROCEDURE orchestrationProc
LANGUAGE SQLSCRIPT AS
BEGIN
DECLARE v_id BIGINT;
DECLARE v_name VARCHAR(30);
DECLARE v_pmnt BIGINT;
DECLARE v_msg VARCHAR(200);
DECLARE CURSOR c_cursor1 (p_payment BIGINT) FOR
SELECT id, name, payment FROM control_tab
WHERE payment > :p_payment ORDER BY id ASC;
CALL init_proc();
OPEN c_cursor1(250000);
FETCH c_cursor1 INTO v_id, v_name, v_pmnt; v_msg = :v_name || ' (id '
|| :v_id || ') earns ' || :v_pmnt || ' $.';
CALL ins_msg_proc(:v_msg);
CLOSE c_cursor1;
END;

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

The procedure features a number of imperative constructs including the use of a cursor (with associated
state) and local scalar variables with assignments.

5.1.2 DROP PROCEDURE

Syntax

DROP PROCEDURE <proc_name> [<drop_option>]

Syntax Elements

<proc_name> ::= [<schema_name>.]<identifier>

The name of the procedure to be dropped, with optional schema name.
<drop_option> ::= CASCADE | RESTRICT
When <drop_option> is not specified, a non-cascaded drop will be performed. This will only drop the specified
procedure, dependent objects of the procedure will be invalidated but not dropped.
The invalidated objects can be revalidated when an object that has same schema and object name is created.
CASCADE
Drops the procedure and dependent objects.
RESTRICT
Drops the procedure only when dependent objects do not exist. If this drop option is used and a dependent
object exists an error will be thrown.

Description
Drops a procedure created using CREATE PROCEDURE from the database catalog.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

Examples
You drop a procedure called my_proc from the database using a non-cascaded drop.
DROP PROCEDURE my_proc;

5.1.3 ALTER PROCEDURE

You can use ALTER PROCEDURE if you want to change the content and properties of a procedure without
dropping the object.
ALTER PROCEDURE <proc_name> [(<parameter_clause>)] [LANGUAGE <lang>]
[DEFAULT SCHEMA <default_schema_name>]
[READS SQL DATA] AS
BEGIN [SEQUENTIAL EXECUTION]
<procedure_body>
END
For more information about the parameters please refer to CREATE PROCEDURE [page 18].
For instance, with ALTER PROCEDURE you can change the content of the body itself. Consider the following
procedure GET_PROCEDURES that returns all procedure names on the database.
CREATE PROCEDURE GET_PROCEDURES(OUT procedures TABLE(schema_name NVARCHAR(256),
name NVARCHAR(256)))
AS
BEGIN
procedures = SELECT schema_name AS schema_name, procedure_name AS name FROM
PROCEDURES;
END;
The procedure GET_PROCEDURES should now be changed to return only valid procedures. In order to do so, we
will use ALTER PROCEDURE:
ALTER PROCEDURE GET_PROCEDURES( OUT procedures TABLE(schema_name NVARCHAR(256),
name NVARCHAR(256)))
AS
BEGIN
procedures = SELECT schema_name AS schema_name, procedure_name AS name FROM
PROCEDURES WHERE IS_VALID = 'TRUE';
END;
Besides changing the procedure body, you can also change the language <lang> of the procedure, the default
schema <default_schema_name> as well as change the procedure to read only mode (READS SQL DATA).

Note
Please note that the following properties cannot be changed with ALTER PROCEDURE:
procedure owner
security mode (INVOKER, DEFINER)
procedure type (table function, scalar function, procedure)

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

parameter signature (parameter name, parameter type, default value)

If you need to change these properties you have to drop and re-create the procedure by using DROP
PROCEDURE and CREATE PROCEDURE.
Note that if the default schema and read only mode are not explicitly specified, they will be removed. Language
will be defaulted to SQLScript.

Note
Note that you need the ALTER privilege for the object you want to change.

5.1.4 ALTER PROCEDURE RECOMPILE

Syntax

ALTER PROCEDURE <proc_name> RECOMPILE [WITH PLAN]

Syntax Elements

<proc_name> ::= [<schema_name>.]<identifier>

The identifier of the procedure to be altered, with optional schema name.
WITH PLAN
Specifies that internal debug information should be created during execution of the procedure.

Description
The ALTER PROCEDURE RECOMPILE statement manually triggers a recompilation of a procedure by
generating an updated execution plan. For production code a procedure should be compiled without the WITH
PLAN option to avoid overhead during compilation and execution of the procedure.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

Example
You trigger the recompilation of the my_proc procedure to produce debugging information.
ALTER PROCEDURE my_proc RECOMPILE WITH PLAN;

5.1.5 Procedure Calls

A procedure can be called by a client on the outer-most level, using any of the supported client interfaces, or
within the body of a procedure.

Recommendation
SAP recommends that you use parameterized CALL statements for better performance. The advantages
follow.
The parameterized query compiles only once, thereby reducing the compile time.
A stored query string in the SQL plan cache is more generic and a precompiled query plan can be
reused for the same procedure call with different input parameters.
By not using query parameters for the CALL statement, the system triggers a new query plan
generation.

5.1.5.1

CALL

Syntax
CALL <proc_name> (<param_list>) [WITH OVERVIEW]

Syntax Elements
<proc_name> ::= [<schema_name>.]<identifier>
The identifier of the procedure to be called, with optional schema name.
<param_list> ::= <proc_param>[{, <proc_param>}...]

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Specifies one or more procedure parameters.

<proc_param> ::= <identifier> | <string_literal> | <unsigned_integer> |
<signed_integer>| <signed_numeric_literal> | <unsigned_numeric_literal> |
<expression>
Procedure parameters. For more information on these data types, see Backus Naur Form Notation [page 7]
and Scalar Datatypes [page 14].
Parameters passed to a procedure are scalar constants and can be passed either as IN, OUT or INOUT
parameters. Scalar parameters are assumed to be NOT NULL. Arguments for IN parameters of table type can
either be physical tables or views. The actual value passed for tabular OUT parameters must be`?`.
WITH OVERVIEW
Defines that the result of a procedure call will be stored directly into a physical table.
Calling a procedure WITH OVERVIEW will return one result set that holds the information of which table
contains the result of a particular table's output variable. Scalar outputs will be represented as temporary
tables with only one cell. When you pass existing tables to the output parameters WITH OVERVIEW will insert
the result set tuples of the procedure into the provided tables. When you pass '?' to the output parameters,
temporary tables holding the result sets will be generated. These tables will be dropped automatically once the
database session is closed.

Description
Calls a procedure defined with CREATE PROCEDURE [page 18].
CALL conceptually returns a list of result sets with one entry for every tabular result. An iterator can be used to
iterate over these results sets. For each result set you can iterate over the result table in the same way as for
query results. SQL statements that are not assigned to any table variable in the procedure body will be added
as result sets at the end of the list of result sets. The type of the result structures will be determined during
compilation time but will not be visible in the signature of the procedure.
CALL when executed by the client the syntax behaves in a way consistent with the SQL standard semantics,
for example, Java clients can call a procedure using a JDBC CallableStatement. Scalar output variables will be
a scalar value that can be retrieved from the callable statement directly.

Note
Unquoted identifiers are implicitly treated as upper case. Quoting identifiers will respect capitalization and
allow for using white spaces which are normally not allowed in SQL identifiers.

Examples
For the examples, consider the following procedure signature:
CREATE PROCEDURE proc(
IN value integer,IN currency nvarchar(10),OUT outTable typeTable,

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

AS
BEGIN

END;

OUT valid integer)

Calling the proc procedure:

CALL proc (1000, 'EUR', ?, ?);
Calling the proc procedure in debug mode:
CALL proc (1000, 'EUR', ?, ?) IN DEBUG MODE;
Calling the proc procedure using the WITH OVERVIEW option:
CALL proc(1000, 'EUR', ?, ?) WITH OVERVIEW;
It is also possible to use scalar user defined function as parameters for procedure call:
CALL proc(udf(),EUR,?,?);
CALL proc(udf()* udf()-55,EUR, ?, ?);
In this example, udf() is a scalar user-defined function. For more information about scalar user-defined
functions, see CREATE FUNCTION [page 42]

5.1.5.2

CALL - Internal Procedure Call

Syntax:
CALL <proc_name > (<param_list>)
Syntax Elements:
<param_list> ::= <param>[{, <param>}...]
Specifies procedure parameters.
<param>::= <in_table_param> | <in_scalar_param> |<out_scalar_param> |
<out_table_param>
Parmeters can be of table or scalar type.
<in_table_param> ::= <read_variable_identifier>|<sql_identifier>
<in_scalar_param>::=<read_variable_identifier>|<scalar_value>|<expression>
<in_param> ::= :<identifier>
Specifies a procedure input parameter.

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Note
Please note the use of a colon in-front of the identifier name.
<out_param> ::= <identifier>
Specifies a procedure input parameter.
Description:
For an internal procedure, where one procedure calls another procedure, all existing variables of the caller or
literals are passed to the IN parameters of the callee and new variables of the caller are bound to the OUT
parameters of the callee. That is to say, the result is implicitly bound to the variable that is given in the function
call.
Example:
CALL addDiscount (:lt_expensive_books, lt_on_sale);
When procedure addDiscount is called, the variable <:lt_expensive_books> is assigned to the function
and the variable <lt_on_sales> is bound by this function call.

Related Information
CALL

5.1.5.3

Call with Named Parameters

You can call a procedure passing named parameters by using the token =>.
For example:
CALL myproc (i => 2)
When you use named parameters you can ignore the order of the parameters in the procedure signature. Run
the following commands and you can try some examples below.
create type mytab_t as table (i int);
create table mytab (i int);
insert into mytab values (0);
insert into mytab values (1);
insert into mytab values (2);
insert into mytab values (3);
insert into mytab values (4);
insert into mytab values (5);
create procedure myproc (in intab mytab_t,in i int, out outtab mytab_t) as
begin
outtab = select i from :intab where i > :i;
end;

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

Now you can use the following CALL possibilities:

call myproc(intab=>mytab, i=>2, outtab =>?);
or
call myproc( i=>2, intab=>mytab, outtab =>?)
Both call formats will produce the same result.

5.1.6 Procedure Parameters

Parameter Modes
The following table lists the parameters you can use when defining your procedures.
Table 3: Parameter modes
Mode

Description

An input parameter

OUT

An output parameter

INOUT

Specifies a parameter that will both pass-in and return data to and from the procedure.

Note
This is only supported for Scalar values.

Supported Parameter Types

Both scalar and table parameter types are supported. For more information on datatypes, see Datatype
Extension

Related Information
Datatype Extension [page 14]

5.1.6.1

Value Binding during Call

Scalar Parameters
Consider the following procedure:
CREATE PROCEDURE test_scalar (IN i INT, IN a VARCHAR)
AS
BEGIN

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SELECT i AS "I", a AS "A" FROM DUMMY;

END;
You can pass parameters using scalar value binding:
CALL test_scalar (1, 'ABC');
You can also use expression binding.
CALL test_scalar (1+1, upper('abc'))
Table parameters
Consider the following procedure:
CREATE
CREATE
CREATE
AS
BEGIN
SELECT
END;

TYPE tab_type AS TABLE (I INT, A VARCHAR);

TABLE tab1 (I INT, A VARCHAR);
PROCEDURE test_table (IN tab tab_type)
* FROM :tab;

You can pass tables and views to the parameter of this function.
CALL test_table (tab1)

Note
Implicit binding of multiple values is currently not supported.
You should always use sql special identifiers when binding a value to a table variable.
CALL test_table ("tab1")
Do not use the following syntax:
CALL test_table ('tab')

5.1.6.2

Default Values for Parameters

In the signature you can define default values for input parameters by using the DEFAULT keyword:
IN <param_name> (<sql_type>|<table_type>|<table_type_definition>) DEFAULT
(<value>|<table_name>)
The usage of the default value will be illustrated in the next example. Therefore the following tables are needed:
CREATE
INSERT
CREATE
INSERT

COLUMN TABLE NAMES(Firstname NVARCHAR(20), LastName NVARCHAR(20));

INTO NAMES VALUES('JOHN', 'DOE');
COLUMN TABLE MYNAMES(Firstname NVARCHAR(20), LastName NVARCHAR(20));
INTO MYNAMES VALUES('ALICE', 'DOE');

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

The procedure in the example generates a FULLNAME by the given input table and delimiter. Whereby default
values are used for both input parameters:
CREATE PROCEDURE FULLNAME(
IN INTAB TABLE(FirstName NVARCHAR (20), LastName NVARCHAR (20)) DEFAULT NAMES,
IN delimiter VARCHAR(10) DEFAULT ', ',
OUT outtab TABLE(fullname NVarchar(50))
)
AS
BEGIN
outtab = SELECT lastname||:delimiter|| firstname AS FULLNAME FROM :intab;
END;
For the tabular input parameter INTAB the default table NAMES is defined and for the scalar input parameter
DELIMITER the , is defined as default. To use the default values in the signature, you need to pass in
parameters using Named Parameters. That means to call the procedure FULLNAME and using the default value
would be done as follows:
CALL FULLNAME (outtab=>?);
The result of that call is:
FULLNAME
-------DOE,JOHN
Now we want to pass a different table, i.e. MYNAMES but still want to use the default delimiter value, the call
looks then as follows:
CALL FULLNAME(INTAB=> MYNAMES, outtab => ?)
And the result shows that now the table MYNAMES was used:
FULLNAME
-------DOE,ALICE

Note
Please note that default values are not supported for output parameters.

Related Information
Call with Named Parameters [page 32]

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

5.1.6.3

DEFAULT EMPTY for Tabular Parameters

For tabular IN and OUT parameter the keyword EMPTY can be used to define an empty input table as a default:
(IN|OUT) <param_name> (<table_type>|<table_type_definition>) DEFAULT EMPTY
Whereas the general default value handling is only supported for input parameters, the DEFAULT EMPTY is
supported for both, tabular IN and OUT parameters.
In the following example we use the DEFAULT EMPTY for the tabular output parameter to be able to declare a
procedure with an empty body.
CREATE PROCEDURE PROC_EMPTY (OUT OUTTAB TABLE(I INT) DEFAULT EMPTY)
AS
BEGIN
END;
Creating the procedure without DEFAULT EMPTY would lead to the error that OUTTAB is not assigned. The
procedure PROC_EMPTY can be called as usual and returns an empty result set:
call PROC_EMPTY (?);
The next example illustrate the usage for a tabular input parameter.
CREATE PROCEDURE CHECKINPUT (IN intab TABLE(I INT ) DEFAULT EMPTY,
OUT result NVARCHAR(20)
)
AS
BEGIN
IF IS_EMPTY(:intab) THEN
result = 'Input is empty';
ELSE
result = 'Input is not empty';
END IF;
END;
Calling the procedure without passing an input table
call CHECKINPUT(result=>?)
leads to the following result:
OUT(1)
----------------'Input is empty'

Note
Please note that DEFAULT EMPTY is so far only supported in a procedure signature.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

5.1.7 Procedure Metadata

When a procedure is created, information about the procedure can be found in the database catalog. You can
use this information for debugging purposes.
The procedures observable in the system views vary according to the privileges that a user has been granted.
The following visibility rules apply:
CATALOG READ or DATA ADMIN All procedures in the system can be viewed.
SCHEMA OWNER, or EXECUTE Only specific procedures where the user is the owner, or they have
execute privileges, will be shown.
Procedures can be exported and imported like tables, see the SQL Reference documentation for details. For
more information see Data Import Export Statements.
The system views for procedures are summarized below:

Related Information
SAP HANA SQL and System Views Reference

5.1.7.1

SYS.PROCEDURES

Available stored procedures

Structure
Table 4:
Column name

Data type

Description

SCHEMA_NAME

NVARCHAR(256)

Schema name of the stored procedure

PROCEDURE_NAME

NVARCHAR(256)

Name of the stored procedure

PROCEDURE_OID

BIGINT

Object ID of the stored procedure

DEFAULT_SCHEMA_NAME

NVARCHAR(256)

Schema name of the unqualified ob

jects in the procedure

INPUT_PARAMETER_COUNT

INTEGER

Input type parameter count

OUTPUT_PARAMETER_COUNT

INTEGER

Output type parameter count

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Column name

Data type

Description

INOUT_PARAMETER_COUNT

INTEGER

In-out type parameter count

RESULT_SET_COUNT

INTEGER

Parameters of stored procedures

Structure
Table 5:
Column name

Data type

Description

LENGTH

INTEGER

Parameter length

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

Column name

Data type

Description

SCALE

INTEGER

Scale of the parameter

POSITION

INTEGER

Ordinal position of the parameter

TABLE_TYPE_SCHEMA

NVARCHAR(256)

Schema name of table type if

DATA_TYPE_NAME is TABLE_TYPE

TABLE_TYPE_NAME

NVARCHAR(256)

Name of table type if

DATA_TYPE_NAME is TABLE_TYPE

PARAMETER_TYPE

VARCHAR(7)

Parameter mode: 'IN', 'OUT', 'INOUT'

HAS_DEFAULT_VALUE

VARCHAR(5)

Specifies whether the parameter has a

default value or not: 'TRUE', 'FALSE'

IS_NULLABLE

VARCHAR(5)

Specifies whether the parameter ac

cepts a null value: 'TRUE', 'FALSE'

5.1.7.3

SYS.OBJECT_DEPENDENCIES

Dependencies between objects, for example, views which refer to a specific table

Structure
Table 6:
Column name

Data type

Description

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Column name

Data type

Description

DEPENDENCY_TYPE

INTEGER

Type of dependency between base and

dependent object. Possible values are:

0: NORMAL (default)

1: EXTERNAL_DIRECT (direct de
pendency between dependent ob
ject and base object)

2: EXTERNAL_INDIRECT (indirect
dependency between dependent
object und base object)

5: REFERENTIAL_DIRECT (foreign
key dependency between tables)

5.1.7.3.1

Object Dependencies View Examples

In this section we explore the ways in which you can query the OBJECT_DEPENDENCIES system view.
You create the following database objects and procedures.
CREATE SCHEMA deps;
CREATE TYPE mytab_t AS TABLE (id int, key_val int, val int);
CREATE TABLE mytab1 (id INT PRIMARY KEY, key_val int, val INT);
CREATE TABLE mytab2 (id INT PRIMARY key, key_val int, val INT);
CREATE PROCEDURE deps.get_tables(OUT outtab1 mytab_t, OUT outtab2 mytab_t)
LANGUAGE SQLSCRIPT READS SQL DATA AS
BEGIN
outtab1 = SELECT * FROM mytab1;
outtab2 = SELECT * FROM mytab2;
END;
CREATE PROCEDURE deps.my_proc (IN val INT, OUT outtab mytab_t) LANGUAGE
SQLSCRIPT READS SQL DATA
AS
BEGIN
CALL deps.get_tables(tab1, tab2);
IF :val > 1 THEN
outtab = SELECT * FROM :tab1;
ELSE
outtab = SELECT * FROM :tab2;
END IF;
END;
Object dependency examination
Firstly you will find all the (direct and indirect) base objects of the procedure DEPS.GET_TABLES. You execute
the following statement.
SELECT * FROM OBJECT_DEPENDENCIES WHERE dependent_object_name = 'GET_TABLES' and
dependent_schema_name = 'DEPS';

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

The result obtained is as follows:

Table 7:
BASE_SCHEM
A_NAME

BASE_OB
JECT_NAME

BASE_OB
JECT_TYPE

DEPEND
ENT_SCHEMA
_NAME

DEPEND
cbfS5D
JECT_NAME

DEPEND
cbfS5D
JECT_TYPE

DEPEND
ENCY_TYPE

SYSTEM

MYTAB_T

TABLE

DEPS

GET_TABLES

PROCEDURE

SYSTEM

MYTAB1

TABLE

DEPS

GET_TABLES

PROCEDURE

SYSTEM

MYTAB2

TABLE

DEPS

GET_TABLES

PROCEDURE

DEPS

GET_TABLES

PROCEDURE

DEPS

GET_TABLES

PROCEDURE

Lets examine the DEPENDENCY_TYPE column in more detail. As you obtained the results in the table above
via a select on all the base objects of the procedure, the objects show include both persistent and transient
objects. You can distinguish between these object dependency types using the DEPENDENCY_TYPE column,
as shown below:

1. EXTERNAL_DIRECT: base object is directly used in the dependent procedure.

2. EXTERNAL_INDIRECT: base object is not directly used in the dependent procedure.
Now you will obtain only the base objects that are used in DEPS.MY_PROC. You execute the following
statement.
SELECT * FROM OBJECT_DEPENDENCIES WHERE dependent_object_name = 'MY_PROC' and
dependent_schema_name = 'DEPS' and dependency_type = 1;
The result obtained is as follows:
Table 8:
BASE_SCHEM
A_NAME

BASE_OB
JECT_NAME

BASE_OB
JECT_TYPE

DEPEND
ENT_SCHEMA
_NAME

DEPEND
cbfS5D
JECT_NAME

DEPEND
cbfS5D
JECT_TYPE

DEPEND
ENCY_TYPE

SYSTEM

MYTAB_T

TABLE

DEPS

MY_PROC

PROCEDURE

DEPS

GET_TABLES

PROCEDURE

DEPS

MY_PROC

PROCEDURE

Finally you find all the dependent objects that are using DEPS.MY_PROC. You execute the following statement.
SELECT * FROM OBJECT_DEPENDENCIES WHERE base_object_name = 'GET_TABLES' and
base_schema_name = 'DEPS' ;
The result obtained is as follows:
Table 9:
BASE_SCHEM
A_NAME

BASE_OB
JECT_NAME

BASE_OB
JECT_TYPE

DEPEND
ENT_SCHEMA
_NAME

DEPEND
cbfS5D
JECT_NAME

DEPEND
cbfS5D
JECT_TYPE

DEPEND
ENCY_TYPE

DEPS

GET_TABLES

PROCEDURE

DEPS

MY_PROC

PROCEDURE

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

5.2

User Defined Function

There are two different kinds of user defined functions (UDF): Table User Defined Functions and Scalar User
Defined Functions. They are referred to as Table UDF and Scalar UDF in the following table. They differ by
input/output parameters, supported functions in the body, and the way they are consumed in SQL
statements.
Table 10:

Functions Calling

Input Parameter

Table UDF

Scalar UDF

A table UDF can only be called in the

FROM clause of an SQL statement in
the same parameter positions as table
names. For example, SELECT * FROM
myTableUDF(1)

A scalar UDF can be called in SQL

statements in the same parameter po
sitions as table column names. These
occur in the SELECT and WHERE
clauses of SQL statements. For exam
ple, SELECT myScalarUDF(1) AS my
Column FROM DUMMY

Primitive SQL type

Table types

Primitive SQL type

Output

Must return a table whose type is de

fined in <return_type>.

Must return scalar values specified in

<return_parameter_list>

Supported functionality

The function is tagged as read only by

default. DDL, DML are not allowed and
only other read-only functions can be
called

The function is tagged as read only

function by default. This type of func
tion does not support any kind of SQL
Statements.

5.2.1 CREATE FUNCTION

This SQL statement creates read-only user defined functions that are free of side-effects. This means that
neither DDL nor DML statements (INSERT, UPDATE, and DELETE) are allowed in the function body. All
functions or procedures selected or called from the body of the function must be read-only.

Syntax

CREATE FUNCTION <func_name> [(<parameter_clause>)] RETURNS <return_type>

[LANGUAGE <lang>] [SQL SECURITY <mode>][DEFAULT SCHEMA <default_schema_name>]
AS
BEGIN
<function_body>
END

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

Syntax Elements

<func_name > ::= [<schema_name>.]<identifier>

The identifier of the function to be created, with optional schema name.

<parameter_clause> ::= <parameter> [{,<parameter>}...]
The input parameters of the function.
<parameter> ::= [IN] <param_name> <param_type>
A function parameter with associated data type.
<param_name> ::= <identifier>
The variable name for a parameter.
<param_type> ::= <sql_type> | <table_type> | <table_type_definition>
Scalar UDF only supports primitive SQL types as input, whereas Table UDF also supports table types as input.
Currently the following primitive SQL types are allowed in scalar UDF:
<sql_type> ::= DATE | TIME | TIMESTAMP | SECONDDATE | TINYINT | SMALLINT |
INTEGER | BIGINT | DECIMAL | SMALLDECIMAL | REAL | DOUBLE | VARCHAR | NVARCHAR |
VARBINARY | ST_GEOMETRY
Table UDF allows a wider range of primitive SQL types:
<sql_type> ::= DATE | TIME | TIMESTAMP | SECONDDATE | TINYINT | SMALLINT |
INTEGER | BIGINT | DECIMAL | SMALLDECIMAL | REAL | DOUBLE | VARCHAR | NVARCHAR |
ALPHANUM | VARBINARY | CLOB | NCLOB | BLOB | ST_GEOMETRY
<table_type> ::= <identifier>
To look at a table type previously defined with the CREATE TYPE command, see CREATE TYPE [page 15].
<table_type_defintion>
::= TABLE (<column_list_definition>)
<column_list_definition > ::= <column_elem>[{, <column_elem>}...]
<column_elem> ::= <column_name> <data_type>
<column_name> ::= <identifier>
A table type implicitly defined within the signature.
<return_type> ::= <return_parameter_list> | <return_table_type>
Table UDF must return a table whose type is defined by <return_table_type>. And scalar UDF must return
scalar values specified in <return_parameter_list>.
<return_parameter_list> ::= <return_parameter>[{, <return_parameter>}...]
<return_parameter>
::= <parameter_name> <sql_type>
Defines the output parameters
<return_table_type> ::= TABLE ( <column_list_definition> )

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Defines the structure of the returned table data.

LANGUAGE <lang>
<lang> ::= SQLSCRIPT
Default: SQLSCRIPT
Defines the programming language used in the function.

Note
Only SQLScript UDF can be defined.
SQL SECURITY <mode>
<mode> ::= DEFINER | INVOKER
Default: DEFINER (Table UDF) / INVOKER (Scalar UDF)
Specifies the security mode of the function.
DEFINER
Specifies that the execution of the function is performed with the privileges of the definer of the function.
INVOKER
Specifies that the execution of the function is performed with the privileges of the invoker of the function.
DEFAULT SCHEMA <default_schema_name>
<default_schema_name> ::= <unicode_name>
Specifies the schema for unqualified objects in the function body. If nothing is specified, then the
current_schema of the session is used.
<function_body>
::= <scalar_function_body>|<table_function_body>
<scalar_function_body> ::= [DECLARE <func_var>]
<proc_assign>
<table_function_body> ::= [<func_block_decl_list>]
[<func_handler_list>]
<func_stmt_list>
<func_return_statement>
Defines the main body of the table UDF and scalar UDF. As the function is flagged as read-only, neither DDL
nor DML statements (INSERT, UPDATE, and DELETE) are allowed in the function body. A scalar UDF does not
support table-typed variables as its input and table operations in the function body.
For the definition of <proc_assign>, see CREATE PROCEDURE [page 18].
<func_block_decl_list>
<func_var>
<array_datatype> } [NOT
<array_datatype>
<array_constructor>
<func_default>
<func_expr>

::= DECLARE { <func_var>|<func_cursor>|<func_condition> }

::= <variable_name_list> [CONSTANT] { <sql_type>|
NULL][<func_default>];
::= <sql_type> ARRAY [ = <array_constructor> ]
::= ARRAY ( <expression> [{,<expression>}...] )
::= { DEFAULT | = } <func_expr>
::= !!An element of the type specified by <sql_type>

Defines one or more local variables with associated scalar type or array type.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

An array type has <type> as its element type. An Array has a range from 1 to 2,147,483,647, which is the
limitation of underlying structure.
You can assign default values by specifying <expression>s. See Expressions in the SAP HANA SQL and
System Views Reference .
<func_handler_list> ::= <proc_handler_list>
See CREATE PROCEDURE [page 18].
<func_stmt_list> ::= <func_stmt>| <func_stmt_list> <func_stmt>
<func_stmt>
::= <proc_block>
| <proc_assign>
| <proc_single_assign>
| <proc_if>
| <proc_while>
| <proc_for>
| <proc_foreach>
| <proc_exit>
| <proc_signal>
| <proc_resignal>
| <proc_open>
| <proc_fetch>
| <proc_close>
For further information of the definitions in <func_stmt>, see CREATE PROCEDURE [page 18]..
<func_return_statement> ::= RETURN <function_return_expr>
<func_return_expr>
::= <table_variable> | <subquery>
A table function must contain a return statement.

Example
How to create a table function is shown in the following example:
CREATE FUNCTION scale (val INT)
RETURNS TABLE (a INT, b INT) LANGUAGE SQLSCRIPT AS
BEGIN
RETURN SELECT a, :val * b AS b FROM mytab;
END;
How to call the table function scale is shown in the following example:
SELECT * FROM scale(10);
SELECT * FROM scale(10) AS a, scale(10) AS b where a.a =

b.a

How to create a scalar function of name func_add_mul that takes two values of type double and returns two
values of type double is shown in the following example:
CREATE FUNCTION func_add_mul(x Double, y Double)
RETURNS result_add Double, result_mul Double
LANGUAGE SQLSCRIPT READS SQL DATA AS
BEGIN
result_add = :x + :y;
result_mul = :x * :y;
END;

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

In a query you can either use the scalar function in the projection list or in the where-clause. In the following
example the func_add_mul is used in the projection list:
CREATE TABLE TAB (a Double, b Double);
INSERT INTO TAB VALUES (1.0, 2.0);
INSERT INTO TAB VALUES (3.0, 4.0);
SELECT a, b, func_add_mul(a, b).result_add as ADD, func_add_mul(a,
b).result_mul as MUL FROM TAB ORDER BY a;
A
B
ADD
MUL
------------------1
2
3
2
3
4
7
12
Besides using the scalar function in a query you can also use a scalar function in scalar assignment, e.g.:
CREATE FUNCTION func_mul(input1 INT)
RETURNS output1 INT LANGUAGE SQLSCRIPT
AS
BEGIN
output1 = :input1 * :input1;
END;
CREATE FUNCTION func_mul_wrapper(input1 INT)
RETURNS output1 INT LANGUAGE SQLSCRIPT AS
BEGIN
output1 = func_mul(:input1);
END;
SELECT func_mul_wrapper(2) as RESULT FROM dummy;
RESULT
----------------4

5.2.2 DROP FUNCTION

Syntax
DROP FUNCTION <func_name> [<drop_option>]

Syntax Elements
<func_name> ::= [<schema_name>.]<identifier>
The name of the function to be dropped, with optional schema name.
<drop_option> ::= CASCADE | RESTRICT
When <drop_option> is not specified a non-cascaded drop will be performed. This will only drop the specified
function, dependent objects of the function will be invalidated but not dropped.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

The invalidated objects can be revalidated when an object that has same schema and object name is created.
CASCADE
Drops the function and dependent objects.
RESTRICT
Drops the function only when dependent objects do not exist. If this drop option is used and a dependent
object exists an error will be thrown.

Description
Drops a function created using CREATE FUNCTION from the database catalog.

Examples
You drop a function called my_func from the database using a non-cascaded drop.
DROP FUNCTION my_func;

5.2.3 ALTER FUNCTION

You can use ALTER FUNCTION if you want to change the content and properties of a function without
dropping the object.
ALTER FUNCTION <func_name> RETURNS <return_type> [LANGUAGE <lang>]
[DEFAULT SCHEMA <default_schema_name>]
AS
BEGIN
<function_body>
END
For more information about the parameters please refer to CREATE FUNCTION. For instance, with ALTER
FUNCTION you can change the content of the body itself. Consider the following procedure GET_FUNCTIONS
that returns all function names on the database.
CREATE FUNCTION GET_FUNCTIONS
returns TABLE(schema_name NVARCHAR(256),
name
NVARCHAR(256))
AS
BEGIN
return SELECT schema_name
AS schema_name,
function_name AS name
FROM FUNCTIONS;
END;

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

The function GET_FUNCTIONS should now be changed to return only valid functions. In order to do so, we will
use ALTER FUNCTION:
ALTER FUNCTION GET_FUNCTIONS
returns TABLE(schema_name NVARCHAR(256),
name
NVARCHAR(256))
AS
BEGIN
return SELECT schema_name
AS schema_name,
function_name AS name
FROM FUNCTIONS
WHERE IS_VALID = 'TRUE';
END;
Besides changing the function body, you can also change the default schema <default_schema_name>.

Note
Please note that the following properties cannot be changed with ALTER FUNCTION:
function owner
security mode (INVOKER, DEFINER)
function type (table function, scalar function, procedure)
parameter signature (parameter name, parameter type, default value)
If you need to change these properties you have to drop and re-create the procedure again by using DROP
FUNCTION and CREATE FUNCTION.
Note that if the default schema is not explicitly specified, it will be removed.

Note
Note that you need the ALTER privilege for the object you want to change.

5.2.4 Function Parameters

The following tables list the parameters you can use when defining your user-defined functions.
Table 11:
Function
Table user-defined functions

Parameter

Can have a list of input parameters and must return a

table whose type is defined in <return type>

Input parameters must be explicitly typed and can have

any of the primitive SQL type or a table type.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

Function

Parameter

Scalar user-defined functions

Can have a list of input parameters and must returns

scalar values specified in <return parameter list>.

Input parameters must be explicitly typed and can have

any primitive SQL type.

Using a table as an input is not allowed.

5.2.5 Function Metadata

When a function is created, information about the function can be found in the database catalog. You can use
this information for debugging purposes. The functions observable in the system views vary according to the
privileges that a user has been granted. The following visibility rules apply:
CATALOG READ or DATA ADMIN All functions in the system can be viewed.
SCHEMA OWNER, or EXECUTE Only specific functions where the user is the owner, or they have
execute privileges, will be shown.

5.2.5.1

SYS.FUNCTIONS

A list of available functions

Structure
Table 12:
Column name

Data type

Description

SCHEMA_NAME

NVARCHAR(256)

Schema name of the function

FUNCTION_NAME

NVARCHAR(256)

Name of the function

FUNCTION_OID

BIGINT

Object ID of the function

INPUT_PARAMETER_COUNT

INTEGER

Input type parameter count

RETURN_VALUE_COUNT

INTEGER

Return value type parameter count

IS_UNICODE

VARCHAR(5)

Specifies whether the function contains

Unicode or not: 'TRUE', 'FALSE'

DEFINITION

SAP HANA SQLScript Reference

Logic Container

NCLOB

Query string of the function

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Column name

Data type

Description

FUNCTION_TYPE

VARCHAR(10)

Type of the function

IS_VALID

VARCHAR(5)

Specifies whether the function is valid

or not. This becomes 'FALSE' when its
base objects are changed or dropped:
'TRUE', 'FALSE'

5.2.5.2

SYS.FUNCTIONS_PARAMETERS

A list of parameters of functions

Structure
Table 13:
Column name

Data type

Description

DATA_TYPE_NAME is TABLE_TYPE

TABLE_TYPE_NAME

NVARCHAR(256)

Name of table type if

DATA_TYPE_NAME is TABLE_TYPE

PARAMETER_TYPE

VARCHAR(7)

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Parameter mode: IN, OUT, INOUT

SAP HANA SQLScript Reference

Logic Container

Column name

Data type

Description

HAS_DEFAULT_VALUE

VARCHAR(5)

Specifies whether the parameter has a

default value or not: 'TRUE', 'FALSE'

IS_NULLABLE

VARCHAR(5)

Specifies whether the parameter ac

cepts a null value: 'TRUE', 'FALSE'

5.2.6 Default Values for Parameters

COLUMN TABLE NAMES(Firstname NVARCHAR(20), LastName NVARCHAR(20));

INTO NAMES VALUES('JOHN', 'DOE');
COLUMN TABLE MYNAMES(Firstname NVARCHAR(20), LastName NVARCHAR(20));
INTO MYNAMES VALUES('ALICE', 'DOE');

The function in the example generates a FULLNAME by the given input table and delimiter. Whereby default
values are used for both input parameters:
CREATE FUNCTION FULLNAME(
IN INTAB TABLE(FirstName NVARCHAR (20), LastName NVARCHAR (20)) DEFAULT NAMES,
IN delimiter VARCHAR(10) DEFAULT ', ')
returns TABLE(fullname NVarchar(50))
AS
BEGIN
return SELECT lastname||:delimiter|| firstname AS FULLNAME FROM :intab;
END;
For the tabular input parameter INTAB the default table NAMES is defined and for the scalar input parameter
DELIMITER the , is defined as default.
That means to query the function FULLNAME and using the default value would be done as follows:
SELECT * FROM

FULLNAME();

The result of that query is:

FULLNAME
-------DOE,JOHN
Now we want to pass a different table, i.e. MYNAMES but still want to use the default delimiter value. To do so
you need to use using Named Parameters to pass in parameters. The query looks then as follows:
SELECT * FROM

FULLNAME(INTAB=> MYNAMES);

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

And the result shows that now the table MYNAMES was used:
FULLNAME
-------DOE,ALICE
In a scalar function, default values can also be used, as shown in the next example:
CREATE FUNCTION GET_FULLNAME(
firstname NVARCHAR(20),
lastName NVARCHAR(20),
delimiter NVARCHAR(10) DEFAULT ','
)
RETURNS fullname NVARCHAR(50)
AS
BEGIN
fullname = :lastname||:delimiter|| :firstname;
END;
Calling that function by using the default value of the variable delimiter would be the following:
SELECT GET__FULLNAME(firstname=>firstname, lastname=>lastname) AS FULLNAME FROM
NAMES;

Note
Please note that default values are not supported for output parameters.

Related Information
Call with Named Parameters [page 32]

5.3

Anonymous Block

Anonymous block is an executable DML statement which can contain imperative or declarative statements.
All SQLScript statements supported in procedures are also supported in anonymous blocks. Compared to
procedures, an anonymous block has no corresponding object created in the metadata catalog.
An anonymous block is defined and executed in a single step by using the following syntax:

Sample Code
DO
BEGIN [SEQUENTIAL EXECUTION]
<procedure_body>
END

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Logic Container

Also contrary to a procedure, an anonymous block has neither parameters nor container-specific properties
(for example, language, security mode, and so on.) However the body of an anonymous block is similar to the
procedure body.
Example 1:

Sample Code
DO
BEGIN
DECLARE I INTEGER;
CREATE TABLE TAB1 (I INTEGER);
FOR I IN 1..10 DO
INSERT INTO TAB1 VALUES (:I);
END FOR;
END;
This example contains an anonymous block that creates a table and inserts values into that table.
Since an anonymous block does not have any parameters defined, the only way to return a result set is by
using SELECT statements, as shown in example 2.
Example 2:

Sample Code
DO
BEGIN
T1 = SELECT I, 10 AS J FROM TAB;
T2 = SELECT I, 20 AS K FROM TAB;
T3 = SELECT J, K FROM :T1, :T2 WHERE :T1.I = :T2.I;
SELECT * FROM :T3;
END
More examples using an anonymous block follow.
Example 3:
In this example, an anonymous block calls another procedure.

Sample Code
DO
BEGIN
T1 = SELECT * FROM TAB;
CALL PROC3(:T1, :T2);
SELECT * FROM :T2;
END
Example 4:
In this example, an anonymous block uses the exception handler.

Sample Code
DO
BEGIN
DECLARE I, J INTEGER;

SAP HANA SQLScript Reference

Logic Container

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

END

BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
IF ::SQL_ERROR_CODE = 288 THEN
DROP TABLE TAB;
CREATE TABLE TAB (I INTEGER PRIMARY KEY);
ELSE
RESIGNAL;
END IF;
CREATE TABLE TAB (I INTEGER PRIMARY KEY);
END;
FOR I in 1..3 DO
INSERT INTO TAB VALUES (:I);
END FOR;
IF :J <> 3 THEN
SIGNAL SQL_ERROR_CODE 10001;
END IF;

Example 5:
In this example, an anonymous block uses commit and rollback.

Sample Code
DO
BEGIN
CREATE TABLE TAB2 (K INT);
COMMIT;
DROP TABLE TAB;
CREATE TABLE TAB (J INT);
ROLLBACK;
DELETE FROM TAB;
END

Declarative SQLScript Logic

Syntax
[IN|OUT] <param_name> {<table_type>|<table_type_definition>}
<table_type> ::= <identifier>
<table_type_definition> ::= TABLE(<column_list_elements>)

Description
Table parameters that are defined in the Signature are either input or output. They must be typed explicitly.
This can be done either by using a table type previously defined with the CREATE TYPE command or by writing
it directly in the signature without any previously defined table type.

Example
(IN inputVar TABLE(I INT),OUT outputVar TABLE (I INT, J DOUBLE))
Defines the tabular structure directly in the signature.
(IN inputVar tableType, OUT outputVar outputTableType)
Using previously defined tableType and outputTableType table types.
The advantage of previously defined table type is that it can be reused by other procedure and functions. The
disadvantage is that you must take care of its lifecycle.
The advantage of a table variable structure that you directly define in the signature is that you do not need to
take care of its lifecycle. In this case, the disadvantage is that it cannot be reused.

6.2

Local Table Variables

Local table variables are, as the name suggests, variables with a reference to tabular data structure. This data
structure originates from an SQL Query.

6.3

Table Variable Type Definition

The type of a table variable in the body of procedure or table function is either derived from the SQL Query or it
can be declared explicitly.

SAP HANA SQLScript Reference

Declarative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

If the table variable derived its type from the SQL Query, the SQLScript compiler determines the type from the
first assignments of that variable. This provides a great deal of flexibility. One disadvantage, however, is that it
also lead to many type conversions in the background. This is because sometimes the derived table type does
not match the typed table parameters at the signature. This can lead to additional conversion costs, which are
unnecessary.
Another disadvantage is the cost for unnecessary internal statement compilation to derive the types.
To avoid this unnecessary cost, you can declare the type of a table variable explicitly.

Signature
DECLARE <sql_identifier> [{,<sql_identifier> }...] [CONSTANT] {TABLE
(<column_list_definition>)|<table_type>} [ <proc_table_default> ]
<proc_table_default> ::= { DEFAULT | '=' } { <select_statement> | <proc_ce_call>
| <proc_apply_filter> | <unnest_function> }
Local table variables are declared using the DECLARE keyword. For the referenced type you can either use
previously declared table type or use the inplace type definition TABLE (<column_list_definition>). The
next example illustrate both variants:

Sample Code
DECLARE temp TABLE (n int);
DECLARE temp MY_TABLE_TYPE;
You can also directly assign a default value to a table variable by using the DEFAULT keyword or =. As a
default all statements are allowed all statements that are also supported for the typical table variable
assignment.
DECLARE temp MY_TABLE_TYPE = UNNEST (:arr) as (i);
DECLARE temp MY_TABLE_TYPE DEFAULT SELECT * FROM TABLE;
The table variable can be also flagged as read-only by using the CONSTANT keyword. The consequence is that
you cannot override the variable anymore. Note that in case the CONSTANT keyword is used the table variable
should have default value since table variable cannot be NULL.
DECLARE temp CONSTANT TABLE(I INT) DEFAULT SELECT * FROM TABLE;

Description
Local table variables are declared using the DECLARE keyword. A table variable temp can be referenced by
using :temp. For more information, see Referencing Variables [page 60]. The <sql_identifier> must be
unique among all other scalar variables and table variables in the same code block. You can, however, use
names that are identical to the name of another variable in a different code block. Additionally, you can
reference these identifiers only in their local scope.
CREATE PROCEDURE exampleExplicit (OUT outTab TABLE(n int))

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Declarative SQLScript Logic

LANGUAGE SQLScript READS SQL DATA AS

BEGIN
DECLARE temp TABLE (n int);
temp = SELECT 1 as n FROM DUMMY ;
BEGIN
DECLARE temp TABLE (n int);
temp = SELECT 2 as n FROM DUMMY ;
outTab = Select * from :temp;
END;
outTab = Select * from :temp;
END;
call exampleExplicit(?);
In each block there are table variables declared with identical names. However, since the last assignment to
the output parameter <outTab> can only have the reference of variable <temp> declared in the same block,
the result is as follows:
N
---1
CREATE PROCEDURE exampleDerived (OUT outTab TABLE(n int))
LANGUAGE SQLScript READS SQL DATA
AS
BEGIN
temp = SELECT 1 as n FROM DUMMY ;
BEGIN
temp = SELECT 2 as n FROM DUMMY ;
outTab = Select * from :temp;
END;
outTab = Select * from :temp;
END;
call exampleDerived (?);
In this code example, there is no explicit table variable declaration where done, that means the <temp>
variable is visible among all blocks. For this reason, the result is as follows:
N
---2
For every assignment of the explicit declared table variable, the derived column names and types on the righthand side are checked against the explicit declared type on the left-hand side.
Another difference, compared to derived types, is that a reference to a table variable without assignment leads
to an error during compile time.
BEGIN
DECLARE a TABLE (i DECIMAL(2,1), j INTEGER);
IF :num = 4
THEN
a = SELECT i, j FROM tab;
END IF;
END;
The example above sends an error because table variable <a> is unassigned if <:num> is not 4. In comparison
the derived table variable type approach would send an error at runtime, but only if <:num> is not 4.

SAP HANA SQLScript Reference

Declarative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

The following table shows the differences:

Table 14:

Create new variable

Variable scope

Unassigned variable check

Derived Type

Explicitly Declared

First SQL Query assignment

Table Variable declaration in a block:

tmp = select * from table;

DECLARE tmp TABLE(i int);

Global scope, regardless of the block

where it was first declared

Available in declared block only.

Pass compile phase even though the

variable can be unassigned in some
cases.

Error in compile phase if there's possi

bility of reference to unassigned table
variable.

Error when unassigned variable is used

But check only when a table variable is

in execution time.

used.

Variable hiding is applied.

(Success if the variable was assigned in If a procedure passed compile phase,

execution time)

there is no possibility of a null referenc

ing error during execution.

Note
The NOT NULL option is not supported (see also the information about scalar variable declaration).

6.4

Binding Table Variables

Table variables are bound using the equality operator. This operator binds the result of a valid SELECT
statement on the right-hand side to an intermediate variable or an output parameter on the left-hand side.
Statements on the right hand side can refer to input parameters or intermediate result variables bound by
other statements. Cyclic dependencies that result from the intermediate result assignments or from calling
other functions are not allowed, that is to say recursion is not possible.

6.5

Referencing Variables

Bound variables are referenced by their name (for example, <var>). In the variable reference the variable
name is prefixed by <:> such as <:var>. The procedure or table function describe a dataflow graph using
their statements and the variables that connect the statements. The order in which statements are written in a
body can be different from the order in which statements are evaluated. In case a table variable is bound
multiple times, the order of these bindings is consistent with the order they appear in the body. Additionally,
statements are only evaluated if the variables that are bound by the statement are consumed by another
subsequent statement. Consequently, statements whose results are not consumed are removed during
optimization.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Declarative SQLScript Logic

Example:
lt_expensive_books = SELECT title, price, crcy FROM :it_books
WHERE price > :minPrice AND crcy = :currency;
In this assignment, the variable <lt_expensive_books> is bound. The <:it_books> variable in the FROM
clause refers to an IN parameter of a table type. It would also be possible to consume variables of type table in
the FROM clause which were bound by an earlier statement. <:minPrice> and <:currency> refer to IN
parameters of a scalar type.

6.6

Column View Parameter Binding

Syntax
SELECT * FROM <column_view> ( <named_parameter_list> );

Syntax Elements
<column_view> ::= <identifier>
The name of the column view.
<named_parameter_list> ::= <named_parameter> [{,<named_parameter>}}]
A list of parameters to be used with the column view.
<named_parameter> ::= <parameter_name> => <expression>
Defines the parameter used to refer to the given expression.
<parameter_name> ::= {PLACEHOLDER.<identifier> | HINT.<identifier> |
<identifier>}
The parameter name definition. PLACEHOLDER is used for place holder parameters and HINT for hint
parameters.

Description
Using column view parameter binding it is possible to pass parameters from a procedure/scripted calculation
view to a parameterized column view e.g. hierarchy view, graphical calculation view, scripted calculation view.

SAP HANA SQLScript Reference

Declarative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Examples:
Example 1 - Basic example
In the following example, assume you have the calculation view CALC_VIEW with placeholder parameters
"client" and "currency". You want to use this view in a procedure and bind the values of the parameters during
the execution of the procedure.
CREATE PROCEDURE my_proc_caller (IN in_client INT, IN in_currency INT, OUT
outtab mytab_t) LANGUAGE SQLSCRIPT READS SQL DATA AS
BEGIN
outtab = SELECT * FROM CALC_VIEW (PLACEHOLDER."$$client$$" => :in_client ,
PLACEHOLDER."$$currency$$" => :in_currency );
END;
Example 2 - Using a Hierarchical View
The following example assumes that you have a hierarchical column view "H_PROC" and you want to use this
view in a procedure. The procedure should return an extended expression that will be passed via a variable.
CREATE PROCEDURE "EXTEND_EXPRESSION"(
IN in_expr nvarchar(20),
OUT out_result "TTY_HIER_OUTPUT")
LANGUAGE SQLSCRIPT READS SQL DATA AS
BEGIN
DECLARE expr VARCHAR(256) = 'leaves(nodes())';
IF :in_expr <> '' THEN
expr = 'leaves(' || :in_expr || ')';
END IF;
out_result = SELECT query_node, result_node FROM h_proc ("expression"
=> :expr ) as h order by h.result_node;
END;
You call this procedure as follows.
CALL "EXTEND_EXPRESSION"('',?);
CALL "EXTEND_EXPRESSION"('subtree("B1")',?);

6.7

HINTS: NO_INLINE and INLINE

The SQLScript compiler combines statements to optimize code. Hints enable you to block or enforce the
inlining of table variables.

Note
Using a HINT needs to be considered carefully. In some cases, using a HINT could end up being more
expensive.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Declarative SQLScript Logic

Block Statement-Inlining
The overall optimization guideline in SQLScript states that dependent statements are combined if possible.
For example, you have two table variable assignments as follows:

Sample Code
tab
tab2

= select A, B, C from T where A = 1;

= select C from :tab where C = 0;

The statements are combined to one statement and executed:

Sample Code
select C from (select A,B,C from T where A = 1) where C=0;
There can be situations, however, when the combined statements lead to a non-optimal plan and as a result, to
less-than-optimal performance of the executed statement. In these situations it can help to block the
combination of specific statements. Therefore SAP has introduced a HINT called NO_INLINE. By placing that
HINT at the end of select statement, it blocks the combination (or inlining) of that statement into other
statements. An example of using this follows:

Sample Code
tab
tab2

= select A, B, C from T where A = 1 WITH HINT(NO_INLINE);

= select C from :tab where C = 0;

By adding WITH HINT (NO_INLINE) to the table variable tab, you can block the combination of that
statement and ensure that the two statements are executed separately.

Enforce Statement-Inlining
Using the hint called INLINE helps in situations when you want to combine the statement of a nested
procedure into the outer procedure.
Currently statements that belong to nested procedure are not combined into the statements of the calling
procedures. In the following example, you have two procedures defined.

Sample Code
CREATE PROCEDURE procInner (OUT tab2 TABLE(I int))
LANGUAGE SQLSCRIPT READS SQL DATA
AS
BEGIN
tab2 = SELECT I FROM T;
END;
CREATE PROCEDURE procCaller (OUT table2 TABLE(I int))
LANGUAGE SQLSCRIPT READS SQL DATA
AS

SAP HANA SQLScript Reference

Declarative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

BEGIN
call procInner (outTable);
table2 = select I from :outTable where I > 10;
END;
By executing the procedure, ProcCaller, the two table assignments are executed separately. If you want to
have both statements combined, you can do so by using WITH HINT (INLINE) at the statement of the
output table variable. Using this example, it would be written as follows:

Sample Code
CREATE PROCEDURE procInner (OUT tab2 TABLE(I int))
LANGUAGE SQLSCRIPT READS SQL DATA
AS
BEGIN
tab2 = SELECT I FROM T WITH HINT (INLINE);
END;
Now, if the procedure, ProcCaller, is executed, then the statement of table variable tab2 in ProcInner is
combined into the statement of the variable, tab, in the procedure, ProcCaller:

Sample Code
SELECT I FROM (SELECT I FROM T WITH HINT (INLINE)) where I > 10;

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Declarative SQLScript Logic

Imperative SQLScript Logic

In this section we will focus on imperative language constructs such as loops and conditionals. The use of
imperative logic splits the logic among several dataflows. For additional information, see Orchestration-Logic
[page 12] and Declarative SQLScript Logic [page 55].

7.1

Local Scalar Variables

Syntax
DECLARE <sql_identifier> [CONSTANT] <type> [NOT NULL] [<proc_default>]

Syntax Elements
<proc_default> ::= (DEFAULT | '=' ) <value>|<expression>
Default value expression assignment.
<value>

!!= An element of the type specified by <type>

DECLARE v INT = 0;
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
val = :a;
END;
v = 1 /(1-:inval);
IF :a = 1 THEN
DECLARE a INT = 2;
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
val = :a;
END;
v = 1 /(2-:inval);
IF :a = 2 THEN
DECLARE a INT = 3;
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
val = :a;
END;
v = 1 / (3-:inval);
END IF;
v = 1 / (4-:inval);
END IF;
v = 1 / (5-:inval);
END;
call nested_block_if(1, ?)
-->OUT:[1]
call nested_block_if(2, ?)
-->OUT:[2]
call nested_block_if(3, ?)
-->OUT:[3]
call nested_block_if(4, ?)
--> OUT:[2]
call nested_block_if(5, ?)
--> OUT:[1]
While Loop
CREATE PROCEDURE nested_block_while(OUT val INT) LANGUAGE SQLSCRIPT READS SQL
DATA AS
BEGIN
DECLARE v int = 2;
val = 0;
WHILE v > 0
DO
DECLARE a INT = 0;
a = :a + 1;
val = :val + :a;
v = :v - 1;
END WHILE;
END;
call nested_block_while(?)
--> OUT:[2]
For Loop
CREATE TABLE mytab1(a int);
CREATE TABLE mytab2(a int);
CREATE TABLE mytab3(a int);
INSERT INTO mytab1 VALUES(1);
INSERT INTO mytab2 VALUES(2);
INSERT INTO mytab3 VALUES(3);
CREATE PROCEDURE nested_block_for(IN inval INT, OUT val INT) LANGUAGE SQLSCRIPT
READS SQL DATA AS
BEGIN
DECLARE a1 int default 0;

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

DECLARE a2 int default 0;

DECLARE a3 int default 0;
DECLARE v1 int default 1;
DECLARE v2 int default 1;
DECLARE v3 int default 1;
DECLARE CURSOR C FOR SELECT * FROM mytab1;
FOR R as C DO
DECLARE CURSOR C FOR SELECT * FROM mytab2;
a1 = :a1 + R.a;
FOR R as C DO
DECLARE CURSOR C FOR SELECT * FROM mytab3;
a2 = :a2 + R.a;
FOR R as C DO
a3 = :a3 + R.a;
END FOR;
END FOR;
END FOR;
IF inval = 1 THEN
val = :a1;
ELSEIF inval = 2 THEN
val = :a2;
ELSEIF inval = 3 THEN
val = :a3;
END IF;
END;
call nested_block_for(1, ?)
--> OUT:[1]
call nested_block_for(2, ?)
--> OUT:[2]
call nested_block_for(3, ?)
--> OUT:[3]
Loop

Note
The example below uses tables and values created in the For Loop example above.
CREATE PROCEDURE nested_block_loop(IN inval INT, OUT val INT) LANGUAGE
SQLSCRIPT READS SQL DATA AS
BEGIN
DECLARE a1 int;
DECLARE a2 int;
DECLARE a3 int;
DECLARE v1 int default 1;
DECLARE v2 int default 1;
DECLARE v3 int default 1;
DECLARE CURSOR C FOR SELECT * FROM mytab1;
OPEN C;
FETCH C into a1;
CLOSE C;
LOOP
DECLARE CURSOR C FOR SELECT * FROM mytab2;
OPEN C;
FETCH C into a2;
CLOSE C;
LOOP
DECLARE CURSOR C FOR SELECT * FROM mytab3;
OPEN C;
FETCH C INTO a3;
CLOSE C;
IF :v2 = 1 THEN
BREAK;
END IF;
END LOOP;
IF :v1 = 1 THEN

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

BREAK;
END IF;
END LOOP;
IF :inval = 1 THEN
val = :a1;
ELSEIF :inval = 2 THEN
val = :a2;
ELSEIF :inval = 3 THEN
val = :a3;
END IF;
END;
call nested_block_loop(1, ?)
--> OUT:[1]
call nested_block_loop(2, ?)
--> OUT:[2]
call nested_block_loop(3, ?)
--> OUT:[3]

7.3

Control Structures

7.3.1 Conditionals
Syntax:
IF <bool_expr1>
THEN
<then_stmts1>
[{ELSEIF <bool_expr2>
THEN
<then_stmts2>}...]
[ELSE
<else_stmts3>]
END IF
Syntax elements:
<bool_expr1>
<bool_expr2>
<condition>
<comparison>
<null_check>

::=
::=
::=
::=
::=

<condition>
<condition>
<comparison> | <null_check>
<comp_val> <comparator> <comp_val>
<comp_val> IS [NOT] NULL

Tests if <comp_val> is NULL or NOT NULL.

Note
NULL is the default value for all local variables.
See Example 2 for an example use of this comparison.
<comparator>

::= < | > | = | <= | >= | !=

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

<comp_val>
::= <scalar_expression>|<scalar_udf>
<scalar_expression> ::=<scalar_value>[{operator}<scalar_value>]
<scalar_value> ::= <numeric_literal> | <exact_numeric_literal>|
<unsigned_numeric_literal>
<operator>::=+|-|/|*
Specifies the comparison value. This can be based on either scalar literals or scalar variables.
<then_stmts1> ::= <proc>
<then_stmts2> ::= <proc_stmts>
<else_stmts3> ::= <proc_stmts>
<proc_stmts> ::= !! SQLScript procedural statements
Defines procedural statements to be executed dependent on the preceding conditional expression.
Description:
The IF statement consists of a Boolean expression <bool_expr1>. If this expression evaluates to true then
the statements <then_stmts1> in the mandatory THEN block are executed. The IF statement ends with END
IF. The remaining parts are optional.
If the Boolean expression <bool_expr1> does not evaluate to true the ELSE-branch is evaluated. The
statements<else_stmts3> are executed without further checks. After an else branch no further ELSE branch
or ELSEIF branch is allowed.
Alternatively, when ELSEIF is used instead of ELSE a further Boolean expression <bool_expr2> is evaluated.
If it evaluates to true, the statements <then_stmts2> are executed. In this manner an arbitrary number of
ELSEIF clauses can be added.
This statement can be used to simulate the switch-case statement known from many programming
languages.
Examples:
Example 1
You use the IF statement to implementing the functionality of the SAP HANA database`s UPSERT statement.
CREATE PROCEDURE upsert_proc (IN v_isbn VARCHAR(20))
LANGUAGE SQLSCRIPT AS
BEGIN
DECLARE found INT = 1;
SELECT count(*) INTO found FROM books WHERE isbn = :v_isbn;
IF :found = 0
THEN
INSERT INTO books
VALUES (:v_isbn, 'In-Memory Data Management', 1, 1,
'2011', 42.75, 'EUR');
ELSE
UPDATE books SET price = 42.75 WHERE isbn =:v_isbn;
END IF;
END;
Example 2
You use the IF statement to check if variable :found is NULL.
SELECT count(*) INTO found FROM books WHERE isbn = :v_isbn;
IF :found IS NULL THEN
CALL ins_msg_proc('result of count(*) cannot be NULL');
ELSE
CALL ins_msg_proc('result of count(*) not NULL - as expected');

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

END IF;
Example 3
It is also possible to use a scalar UDF in the condition, as shown in the following example.
CREATE PROCEDURE proc (in input1 INTEGER, out output1 TYPE1)
AS
BEGIN
DECLARE i INTEGER DEFAULT :input1;
IF SUDF(:i) = 1 THEN
output1 = SELECT value FROM T1;
ELSEIF SUDF(:i) = 2 THEN
output1 = SELECT value FROM T2;
ELSE
output1 = SELECT value FROM T3;
END IF;
END;

Related Information
ins_msg_proc [page 152]

7.3.2 While Loop

Syntax:
WHILE <condition> DO
<proc_stmts>
END WHILE
Syntax elements:
<null_check>
::= <comp_val> IS [NOT] NULL
<comparator>
::= < | > | = | <= | >= | !=
<comp_val>
::= <scalar_expression>|<scalar_udf>
<scalar_expression> ::=<scalar_value>[{operator}<scalar_value>]
<scalar_value> ::= <numeric_literal> | <exact_numeric_literal>|
<unsigned_numeric_literal>
<operator>::=+|-|/|*
Defines a Boolean expression which evaluates to true or false.
<proc_stmts> ::= !! SQLScript procedural statements
Description:
The while loop executes the statements <proc_stmts> in the body of the loop as long as the Boolean
expression at the beginning <condition> of the loop evaluates to true.
Example 1

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

You use WHILE to increment the :v_index1 and :v_index2 variables using nested loops.
CREATE PROCEDURE procWHILE (OUT V_INDEX2 INTEGER) LANGUAGE SQLSCRIPT
READS SQL DATA
AS
BEGIN
DECLARE v_index1 INT = 0;
WHILE :v_index1 < 5 DO
v_index2 = 0;
WHILE :v_index2 < 5 DO
v_index2 = :v_index2 + 1;
END WHILE;
v_index1 = :v_index1 + 1;
END WHILE;
END;
Example 2
You can also use scalar UDF for the while condition as follows.
CREATE PROCEDURE proc (in input1 INTEGER, out output1 TYPE1)
AS
BEGIN
DECLARE i INTEGER DEFAULT :input1;
DECLARE cnt INTEGER DEFAULT 0;
WHILE SUDF(:i) > 0 DO
cnt = :cnt + 1;
i = :i - 1;
END WHILE;
output1 = SELECT value FROM T1 where id = :cnt ;
END;

Caution
No specific checks are performed to avoid infinite loops.

7.3.3 For Loop

Syntax:
FOR <loop-var> IN [REVERSE] <start_value> .. <end_value> DO
<proc_stmts>
END FOR
Syntax elements:
<loop-var> ::= <identifier>
Defines the variable that will contain the loop values.
REVERSE
When defined causes the loop sequence to occur in a descending order.
<start_value> ::= <signed_integer>

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Defines the starting value of the loop.

<end_value> ::=

<signed_integer>

Defines the end value of the loop.

<proc_stmts> ::= !! SQLScript procedural statements
Defines the procedural statements that will be looped over.
Description:
The for loop iterates a range of numeric values and binds the current value to a variable <loop-var> in
ascending order. Iteration starts with the value of <start_value> and is incremented by one until the
<loop-var> is greater than <end_value> .
If <start_value> is larger than <end_value>, <proc_stmts> in the loop will not be evaluated.
Example 1
You use nested FOR loops to call a procedure that traces the current values of the loop variables appending
them to a table.
CREATE PROCEDURE proc (out output1 TYPE1) LANGUAGE SQLSCRIPT
READS SQL DATA
AS
BEGIN
DECLARE pos INTEGER DEFAULT 0;
DECLARE i INTEGER;
FOR i IN 1..10 DO
pos = :pos + 1;
END FOR;
output1 = SELECT value FROM T1 where position = :i ;
END;
Example 2
You can also use scalar UDF in the FOR loop, as shown in the following example.
CREATE PROCEDURE proc (out output1 TYPE1)LANGUAGE SQLSCRIPT
READS SQL DATA
AS
BEGIN
DECLARE pos INTEGER DEFAULT 0;
DECLARE i INTEGER;
FOR i IN 1..SUDF_ADD(1, 2) DO
pos = :pos + 1;
END FOR;
output1 = SELECT value FROM T1 where position = :i ;
END;

7.3.4 Break and Continue

Syntax:
BREAK
CONTINUE

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

Syntax elements:
BREAK
Specifies that a loop should stop being processed.
CONTINUE
Specifies that a loop should stop processing the current iteration, and should immediately start processing the
next.
Description:
These statements provide internal control functionality for loops.
Example:
You defined the following loop sequence. If the loop value :x is less than 3 the iterations will be skipped. If :x is
5 then the loop will terminate.
CREATE PROCEDURE proc () LANGUAGE SQLSCRIPT
READS SQL DATA
AS
BEGIN
DECLARE x integer;
FOR x IN 0 .. 10 DO
IF :x < 3 THEN
CONTINUE;
END IF;
IF :x = 5 THEN
BREAK;
END IF;
END FOR;
END;

Related Information
ins_msg_proc [page 152]

7.4

Cursors

Cursors are used to fetch single rows from the result set returned by a query. When the cursor is declared it is
bound to a query. It is possible to parameterize the cursor query.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

7.4.1 Define Cursor

Syntax:
CURSOR <cursor_name> [({<param_def>{,<param_def>} ...)]
FOR <select_stmt>
Syntax elements:
<cursor_name> ::= <identifier>
Specifies the name of the cursor.
<param_def> = <param_name> <param_type>
Defines an optional SELECT parameter.
<param_name> ::= <identifier>
Defines the variable name of the parameter.
<param_type> ::=
|
|
|

DATE | TIME | SECONDDATE | TIMESTAMP | TINYINT

Defines the datatype of the parameter.

<select_stmt> !!= SQL SELECT statement.
Defines an SQL select statement. See SELECT.
Description:
Cursors can be defined either after the signature of the procedure and before the procedures body or at the
beginning of a block with the DECLARE token. The cursor is defined with a name, optionally a list of parameters,
and an SQL SELECT statement. The cursor provides the functionality to iterate through a query result row-byrow. Updating cursors is not supported.

Note
Avoid using cursors when it is possible to express the same logic with SQL. You should do this as cursors
cannot be optimized the same way SQL can.
Example:
You create a cursor c_cursor1 to iterate over results from a SELECT on the books table. The cursor passes
one parameter v_isbn to the SELECT statement.
DECLARE CURSOR c_cursor1 (v_isbn VARCHAR(20)) FOR
SELECT isbn, title, price, crcy FROM books
WHERE isbn = :v_isbn ORDER BY isbn;

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

Related Information
SAP HANA SQL and System Views Reference

7.4.2 Open Cursor

Syntax:
OPEN <cursor_name>[(<argument_list>)]
Syntax elements:
<cursor_name> ::= <identifier>
Specifies the name of the cursor to be opened.
<argument_list> ::= <arg>[,{<arg>}...]
Specifies one or more arguments to be passed to the select statement of the cursor.
<arg> ::= <scalar_value>
Specifies a scalar value to be passed to the cursor.
Description:
Evaluates the query bound to a cursor and opens the cursor so that the result can be retrieved. When the
cursor definition contains parameters then the actual values for each of these parameters must be provided
when the cursor is opened.
This statement prepares the cursor so the results can be fetched for the rows of a query.
Example:
You open the cursor c_cursor1 and pass a string '978-3-86894-012-1' as a parameter.
OPEN c_cursor1('978-3-86894-012-1');

7.4.3 Close Cursor

Syntax:
CLOSE <cursor_name>
Syntax elements:
<cursor_name> ::= <identifier>
Specifies the name of the cursor to be closed.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Description:
Closes a previously opened cursor and releases all associated state and resources. It is important to close all
cursors that were previously opened.
Example:
You close the cursor c_cursor1.
CLOSE c_cursor1;

7.4.4 Fetch Query Results of a Cursor

Syntax:
FETCH <cursor_name> INTO <variable_list>
Syntax elements:
<cursor_name> ::= <identifier>
Specifies the name of the cursor where the result will be obtained.
<variable_list> ::= <var>[,{<var>}...]
Specifies the variables where the row result from the cursor will be stored.
<var> ::= <identifier>
Specifies the identifier of a variable.
Description:
Fetches a single row in the result set of a query and advances the cursor to the next row. This assumes that
the cursor was declared and opened before. One can use the cursor attributes to check if the cursor points to
a valid row. See Attributes of a Cursor
Example:
You fetch a row from the cursor c_cursor1 and store the results in the variables shown.
FETCH c_cursor1 INTO v_isbn, v_title, v_price, v_crcy;

Related Information
Attributes of a Cursor [page 79]

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

7.4.5 Attributes of a Cursor

A cursor provides a number of methods to examine its current state. For a cursor bound to variable
c_cursor1, the attributes summarized in the table below are available.
Table 15: Cursor Attributes
Attribute

Description

c_cursor1::ISCLOSED

Is true if cursor c_cursor1 is closed, otherwise false.

c_cursor1::NOTFOUND

Is true if the previous fetch operation returned no valid row,

false otherwise. Before calling OPEN or after calling CLOSE
on a cursor this will always return true.

c_cursor1::ROWCOUNT

Returns the number of rows that the cursor fetched so far.

This value is available after the first FETCH operation. Be
fore the first fetch operation the number is 0.

Example:
The example below shows a complete procedure using the attributes of the cursor c_cursor1 to check if
fetching a set of results is possible.
CREATE PROCEDURE cursor_proc LANGUAGE SQLSCRIPT AS
BEGIN
DECLARE v_isbn
VARCHAR(20);
DECLARE v_title VARCHAR(20);
DECLARE v_price DOUBLE;
DECLARE v_crcy VARCHAR(20);
DECLARE CURSOR c_cursor1 (v_isbn VARCHAR(20)) FOR
SELECT isbn, title, price, crcy FROM books
WHERE isbn = :v_isbn ORDER BY isbn;
OPEN c_cursor1('978-3-86894-012-1');
IF c_cursor1::ISCLOSED THEN
CALL ins_msg_proc('WRONG: cursor not open');
ELSE
CALL ins_msg_proc('OK: cursor open');
END IF;
FETCH c_cursor1 INTO v_isbn, v_title, v_price, v_crcy;
IF c_cursor1::NOTFOUND THEN
CALL ins_msg_proc('WRONG: cursor contains no valid data');
ELSE
CALL ins_msg_proc('OK: cursor contains valid data');
END IF;
CLOSE c_cursor1;
END

Related Information
ins_msg_proc [page 152]

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

7.4.6 Looping over Result Sets

Syntax:
FOR <row_var> AS <cursor_name>[(<argument_list>)] DO
<proc_stmts> | {<row_var>.<column>}
END FOR
Syntax elements:
<row_var> ::= <identifier>
Defines an identifier to contain the row result.
<cursor_name> ::= <identifier>
Specifies the name of the cursor to be opened.
<argument_list> ::= <arg>[,{<arg>}...]
Specifies one or more arguments to be passed to the select statement of the cursor.
<arg> ::= <scalar_value>
Specifies a scalar value to be passed to the cursor.
<proc_stmts> ::= !! SQLScript procedural statements
Defines the procedural statements that will be looped over.
<row_var>.<column> ::= !! Provides attribute access
To access the row result attributes in the body of the loop you use the syntax shown.
Description:
Opens a previously declared cursor and iterates over each row in the result set of the query bound to the
cursor. For each row in the result set the statements in the body of the procedure are executed. After the last
row from the cursor has been processed, the loop is exited and the cursor is closed.

Tip
As this loop method takes care of opening and closing cursors, resource leaks can be avoided.
Consequently this loop is preferred to opening and closing a cursor explicitly and using other loop-variants.
Within the loop body, the attributes of the row that the cursor currently iterates over can be accessed like an
attribute of the cursor. Assuming <row_var> isa_row and the iterated data contains a column test, then the
value of this column can be accessed using a_row.test.
Example:
The example below demonstrates using a FOR-loop to loop over the results from c_cursor1 .
CREATE PROCEDURE foreach_proc() LANGUAGE SQLSCRIPT AS
BEGIN
DECLARE v_isbn
VARCHAR(20) = '';

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

DECLARE CURSOR c_cursor1 (v_isbn VARCHAR(20)) FOR

SELECT isbn, title, price, crcy FROM books
ORDER BY isbn;
FOR cur_row AS c_cursor1(v_isbn)
DO
CALL ins_msg_proc('book title is: ' || cur_row.title);
END FOR;
END;

Related Information
ins_msg_proc [page 152]

7.5

Autonomous Transaction

Syntax:
<proc_bloc> :: = BEGIN AUTONOMOUS TRANSACTION
[<proc_decl_list>]
[<proc_handler_list>]
[<proc_stmt_list>]
END;
Description:
The autonomous transaction is independent from the main procedure. Changes made and committed by an
autonomous transaction can be stored in persistency regardless of commit/rollback of the main procedure
transaction. The end of the autonomous transaction block has an implicit commit.
BEGIN AUTONOMOUS TRANSACTION
(some updates) (1)
COMMIT;
(some updates) (2)
ROLLBACK;
(some updates) (3)
END;
The examples show how commit and rollback work inside the autonomous transaction block. The first updates
(1) are committed, whereby the updates made in step (2) are completely rolled back. And the last updates (3)
are committed by the implicit commit at the end of the autonomous block.
CREATE PROCEDURE PROC1( IN p INT , OUT outtab TABLE (A INT)) LANGUAGE SQLSCRIPT
AS
BEGIN
DECLARE errCode INT;
DECLARE errMsg VARCHAR(5000);
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN AUTONOMOUS TRANSACTION
errCode= ::SQL_ERROR_CODE;
errMsg= ::SQL_ERROR_MESSAGE ;
INSERT INTO ERR_TABLE (PARAMETER,SQL_ERROR_CODE, SQL_ERROR_MESSAGE)
VALUES ( :p, :errCode, :errMsg);
END;

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

outtab = SELECT 1/:p as A FROM DUMMY;

END

-- DIVIDE BY ZERO Error if p=0

In the example above, an autonomous transaction is used to keep the error code in the ERR_TABLE stored in
persistency.
If the exception handler block were not an autonomous transaction, then every insert would be rolled back
because they were all made in the main transaction. In this case the result of the ERR_TABLE is as shown in the
following example.
P |SQL_ERROR_CODE| SQL_ERROR_MESSAGE
-------------------------------------------0 |
304
| division by zero undefined:

at function /()

It is also possible to have nested autonomous transactions.

CREATE PROCEDURE P2()
AS BEGIN
BEGIN AUTONOMOUS TRANSACTION
INSERT INTO LOG_TABLE VALUES ('MESSAGE');
BEGIN AUTONOMOUS TRANSACTION
ROLLBACK;
END;
END;
END;
The LOG_TABLE table contains 'MESSAGE', even though the inner autonomous transaction rolled back.
Supported statements inside the block
SELECT, INSERT, DELETE, UPDATE, UPSERT, REPLACE
IF, WHILE, FOR, BEGIN/END
COMMIT, ROLLBACK, RESIGNAL, SIGNAL
Scalar variable assignment
Unsupported statements inside the block
Calling other procedures
DDL
Cursor
Table assignments

Note
You have to be cautious if you access a table both before and inside an autonomous transaction started in a
nested procedure (e.g. TRUNCATE, update the same row), because this can lead to a deadlock situation.
One solution to avoid this is to commit the changes before entering the autonomous transaction in the
nested procedure.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

7.6

COMMIT and ROLLBACK

The COMMIT and ROLLBACK commands are supported natively in SQLScript.

The COMMIT command commits the current transaction and all changes before the COMMIT command is
written to persistence.
The ROLLBACK command rolls back the current transaction and undoes all changes since the last COMMIT.
Example 1:

Sample Code
CREATE PROCEDURE PROC1() AS
BEGIN
UPDATE B_TAB SET V = 3 WHERE ID = 1;
COMMIT;
UPDATE B_TAB SET V = 4 WHERE ID = 1;
ROLLBACK;
END;
In this example, the B_TAB table has one row before the PROC1 procedure is executed:
Table 16:
V

After you execute the PROC1 procedure, the B_TAB table is updated as follows:
Table 17:
V

This means only the first update in the procedure affected the B_TAB table. The second update does not affect
the B_TAB table because it was rolled back.
The following graphic provides more detail about the transactional behavior. With the first COMMIT command,
transaction tx1 is committed and the update on the B_TAB table is written to persistence. As a result of the
COMMIT, a new transaction starts, tx2.
By triggering ROLLBACK, all changes done in transaction tx2 are reverted. In Example 1, the second update is
reverted. Additionally after the rollback is performed, a new transaction starts, tx3.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

The transaction boundary is not tied to the procedure block. This means that if a nested procedure contains a
COMMIT/ROLLBACK, then all statements of the top-level procedure are affected.
Example 2:

Sample Code
CREATE PROCEDURE PROC2()
BEGIN
UPDATE B_TAB SET V =
COMMIT;
END;
CREATE PROCEDURE PROC1()
BEGIN
UPDATE A_TAB SET V =
CALL PROC2();
UPDATE A_TAB SET V =
ROLLBACK;
END;

AS
3 WHERE ID = 1;
AS
2 WHERE ID = 1;
3 WHERE ID = 1;

In Example 2, the PROC1 procedure calls the PROC2procedure. The COMMIT in PROC2 commits all changes
done in the tx1 transaction (see the following graphic). This includes the first update statement in the PROC1
procedure as well as the update statement in the PROC2 procedure. With COMMIT a new transaction starts
implicitly, tx2.
Therefore the ROLLBACK command in PROC1 only affects the previous update statement; all other updates
were committed with the tx1 transaction.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

Note
If you used DSQL in the past to execute these commands (for example, EXEC COMMIT,
EXEC ROLLBACK), SAP recommends that you replace all occurrences with the native commands
COMMIT/ROLLBACK because they are more secure.
The COMMIT/ROLLBACK commands are not supported in Scalar UDF or in Table UDF.

7.7

Dynamic SQL

7.8

Exception Handling

Exception handling is a method for handling exception and completion conditions in an SQLScript procedure.

7.8.1 DECLARE EXIT HANDLER

The DECLARE EXIT HANDLER parameter allows you to define an exit handler to process exception conditions
in your procedure or function.
DECLARE EXIT HANDLER FOR <proc_condition_value> {,<proc_condition_value>}...]
<proc_stmt>
<proc_condition_value> ::= SQLEXCEPTION
| SQL_ERROR_CODE <error_code>

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

| <condition_name>

For example the following exit handler catches all SQLEXCEPTION and returns the information that an
exception was thrown:
DECLARE EXIT HANDLER FOR SQLEXCEPTION SELECT 'EXCEPTION was thrown' AS ERROR
FROM dummy;
For getting the error code and the error message the two system variables ::SQL_ERROR_CODE
and ::SQL_ERROR_MESSAGE can be used as it is shown in the next example:
CREATE PROCEDURE MYPROC (IN in_var INTEGER, OUT outtab TABLE(I INTEGER) ) AS
BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE FROM DUMMY;
outtab = SELECT 1/:in_var as I FROM dummy;
END;
By setting <in_var> = 0 the result of the procedure execution would be:
::SQL_ERROR_CODE

::SQL_ERROR_MESSAGE

304

Division by zero undefined: the right-hand value of the division cannot be zero
at function /() (please check lines: 6)

Besides defining an exit handler for an arbitrary SQLEXCEPTION you can also define it for a specific error code
number by using the keyword SQL_ERROR_CODE followed by an SQL error code number.
For example if only the division-by-zero error should be handled the exception handler looks as follows:
DECLARE EXIT HANDLER FOR SQL_ERROR_CODE 304
SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE FROM DUMMY;

Please note that only the SQL (code strings starting with ERR_SQL_*) and SQLScript (code strings starting
with ERR_SQLSCRIPT_*) error codes are supported in the exit handler. You can use the system view
M_ERROR_CODES to get more information about the error codes.
Instead of using an error code the exit handler can be also defined for a condition.
DECLARE EXIT HANDLER FOR MY_COND
SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE FROM DUMMY;

The original SQL error message will be now replaced by the new one:
[304]: division by zero undefined: [304] "SYSTEM"."MY": line 4 col 10 (at pos
131): [304] (range 3) division by zero undefined exception: for the input
parameter in_var = 0 exception was raised

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

The original error message you can get via the system variable ::SQL_ERROR_MESSAGE, e.g. this is useful if
you still want to keep the original message, but like to add additional information:
CREATE PROCEDURE MY (IN in_var INTEGER, OUT outtab TABLE(I INTEGER) )
AS
BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
RESIGNAL SET MESSAGE_TEXT = 'for the input parameter in_var = '||
:in_var || ' exception was raised '
|| ::SQL_ERROR_MESSAGE;
outtab = SELECT 1/:in_var as I FROM dummy;
END;

7.8.4 Exception Handling Examples

General exception handling

General exception can be handled with exception handler declared at the beginning of statements which make
an explicit or implicit signal exception.
CREATE TABLE MYTAB (I INTEGER PRIMARYKEY);
CREATE PROCEDURE MYPROC AS BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE FROM DUMMY;
INSERT INTO MYTAB VALUES (1);
INSERT INTO MYTAB VALUES (1); -- expected unique violation error: 301
-- will not be reached
END;
CALL MYPROC;

Error code exception handling

An exception handler can be declared that catches exceptions with a specific error code numbers.
CREATE TABLE MYTAB (I INTEGER PRIMARY KEY);
CREATE PROCEDURE MYPROC AS
BEGIN
DECLARE EXIT HANDLER FOR SQL_ERROR_CODE 301
SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE FROM DUMMY;
INSERT INTO MYTAB VALUES (1);
INSERT INTO MYTAB VALUES (1); -- expected unique violation error: 301
-- will not be reached
END;
CALL MYPROC;
CREATE TABLE MYTAB (I INTEGER PRIMARY KEY);
CREATE PROCEDURE MYPROC AS

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

BEGIN
DECLARE myVar INT;
DECLARE EXIT HANDLER FOR SQL_ERROR_CODE 1299
BEGIN
SELECT 0 INTO myVar FROM DUMMY;
SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE FROM DUMMY;
SELECT :myVar FROM DUMMY;
END;
SELECT I INTO myVar FROM MYTAB; --NO_DATA_FOUND exception
SELECT 'NeverReached_noContinueOnErrorSemantics' FROM DUMMY;
END;
CALL MYPROC;

Conditional Exception Handling

Exceptions can be declared using a CONDITION variable. The CONDITION can optionally be specified with an
error code number.
CREATE TABLE MYTAB (I INTEGER PRIMARY KEY);
CREATE PROCEDURE MYPROC AS
BEGIN
DECLARE MYCOND CONDITION FOR SQL_ERROR_CODE 301;
DECLARE EXIT HANDLER FOR MYCOND SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE
FROM DUMMY;
INSERT INTO MYTAB VALUES (1);
INSERT INTO MYTAB VALUES (1); -- expected unique violation error: 301
-- will not be reached
END;
CALL MYPROC;

Signal an exception
The SIGNAL statement can be used to explicitly raise an exception from within your procedures.

Note
The error code used must be within the user-defined range of 10000 to 19999.

CREATE TABLE MYTAB (I INTEGER PRIMARY KEY);

CREATE PROCEDURE MYPROC AS
BEGIN
DECLARE MYCOND CONDITION FOR SQL_ERROR_CODE 10001;
DECLARE EXIT HANDLER FOR MYCOND SELECT ::SQL_ERROR_CODE, ::SQL_ERROR_MESSAGE
FROM DUMMY;
INSERT INTO MYTAB VALUES (1);
SIGNAL MYCOND SET MESSAGE_TEXT = 'my error';
-- will not be reached
END;
CALL MYPROC;

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

Resignal an exception
The RESIGNAL statement raises an exception on the action statement in exception handler. If error code is not
specified, RESIGNAL will throw the caught exception.
CREATE TABLE MYTAB (I INTEGER PRIMARY KEY);
CREATE PROCEDURE MYPROC AS
BEGIN
DECLARE MYCOND CONDITION FOR SQL_ERROR_CODE 10001;
DECLARE EXIT HANDLER FOR MYCOND RESIGNAL;
INSERT INTO MYTAB VALUES (1);
SIGNAL MYCOND SET MESSAGE_TEXT = 'my error';
-- will not be reached
END;
CALL MYPROC;

Nested block exceptions.

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

Optionally the ORDER BY clause can be used to determine the order of the elements in the array. If it is not
specified, the array elements are ordered non-deterministic. In the following example all elements of array id
are sorted descending by column B.
id

= ARRAY_AGG(:tab.A ORDER BY B DESC);

Additionally it is also possible to define where NULL values should appear in the result set. By default NULL
values are returned first for ascending ordering, and last for descending ordering. You can override this
behavior using NULLS FIRST or NULLS LAST to explicitly specify NULL value ordering. The next example
shows how the default behavior for the descending ordering can be overwritten by using NULLS FIRST:
CREATE COLUMN TABLE CTAB (A NVARCHAR(10));
INSERT INTO CTAB VALUES ('A1');
INSERT INTO CTAB VALUES (NULL);
INSERT INTO CTAB VALUES ('A2');
INSERT INTO CTAB VALUES (NULL);
DO
BEGIN
DECLARE id NVARCHAR(10) ARRAY;
tab = SELECT A FROM ctab;
id = ARRAY_AGG(:tab.A ORDER BY A DESC NULLS FIRST);
tab2 = UNNEST(:id) AS (A);
SELECT * FROM :tab2;
END;

Note
ARRAY_AGG function does not support using value expressions instead of table variables.

7.9.6 TRIM_ARRAY
The TRIM_ARRAY function removes elements from the end of an array. TRIM_ARRAY returns a new array with
a <trim_quantity> number of elements removed from the end of the array <array_variable>.
TRIM_ARRAY(:<array_variable>, <trim_quantity>)
<array_variable> ::= <identifier>
<trim_quantity> ::= <unsigned_integer>
For example, removing the last 2 elements of array array_id:
CREATE PROCEDURE ARRAY_TRIM(OUT rst TABLE (ID INTEGER))
LANGUAGE SQLSCRIPT SQL SECURITY INVOKER AS
BEGIN
DECLARE array_id
Integer ARRAY := ARRAY(1, 2, 3, 4);
array_id = TRIM_ARRAY(:array_id, 2);
rst
= UNNEST(:array_id) as ("ID");
END;
The result of calling this procedure is as follows:
ID
---

100

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

103

Example:
create table mytab(myval varchar(20));
insert into mytab values('Val1');
create procedure change_value(
in tabname varchar(20),
in field varchar(20),
in old_val varchar(20),
in new_val varchar(20)
) as
begin
declare sqlstr nclob;
sqlstr := 'UPDATE "' ||:tabname || '" SET ' || field || ' = ''' ||
new_val || ''' WHERE ' || field || ' = ''' || old_val || '''';
exec(:sqlstr);
end
The following values of input parameters can manipulate the dynamic SQL statement in an unintended way:
tabname: mytab" set myval = ' ' - field: myval = ' ' - new_val: ' - old_val: ' or 1 = 1 -This cannot happen if you validate and/or process the input values:
create procedure change_value(
in tabname varchar(20),
in field varchar(20),
in old_val varchar(20),
in new_val varchar(20)
) as
begin
declare sqlstr nclob;
declare mycond condition for sql_error_code 10001;
if is_sql_injection_safe(field) <> 1 then
signal mycond set message_text = 'Invalid field ' || field;
end if;
sqlstr := 'UPDATE "' || escape_double_quotes(:tabname) || '" SET ' ||
field || ' = ''' || escape_single_quotes(:new_val) || ''' WHERE ' || field
|| ' = ''' || escape_single_quotes(:old_val) || '''';
exec(:sqlstr);
end

Syntax IS_SQL_INJECTION_SAFE
IS_SQL_INJECTION_SAFE(<value>[, <max_tokens>])

Syntax Elements
<value> ::= <string>
String to be checked.

104

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

<max_tokens> ::= <integer>

Maximum number of tokens that is allowed to be in <value>. The default value is 1.

Description
Checks for possible SQL injection in a parameter which is to be used as a SQL identifier. Returns 1 if no
possible SQL injection is found, otherwise 0.

Example
The following code example shows that the function returns 0 if the number of tokens in the argument is
different from the expected number of a single token (default value).
SELECT IS_SQL_INJECTION_SAFE('tab,le') "safe" FROM DUMMY;
safe
------0
The following code example shows that the function returns 1 if the number of tokens in the argument matches
the expected number of 3 tokens.
SELECT IS_SQL_INJECTION_SAFE('CREATE STRUCTURED PRIVILEGE', 3) "safe" FROM DUMMY;
safe
------1

Syntax ESCAPE_SINGLE_QUOTES

ESCAPE_SINGLE_QUOTES(<value>)

Description
Escapes single quotes (apostrophes) in the given string <value>, ensuring a valid SQL string literal is used in
dynamic SQL statements to prevent SQL injections. Returns the input string with escaped single quotes.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

105

Example
The following code example shows how the function escapes a single quote. The one single quote is escaped
with another single quote when passed to the function. The function then escapes the parameter content
Str'ing to Str''ing, which is returned from the SELECT.
SELECT ESCAPE_SINGLE_QUOTES('Str''ing') "string_literal" FROM DUMMY;
string_literal
--------------Str''ing

Syntax ESCAPE_DOUBLE_QUOTES
ESCAPE_DOUBLE_QUOTES(<value>)

Description
Escapes double quotes in the given string <value>, ensuring a valid SQL identifier is used in dynamic SQL
statements to prevent SQL injections. Returns the input string with escaped double quotes.

Example
The following code example shows that the function escapes the double quotes.
SELECT ESCAPE_DOUBLE_QUOTES('TAB"LE') "table_name" FROM DUMMY;
table_name
-------------TAB""LE

7.13 Explicit Parallel Execution for DML

So far implicit parallelization is applied to table variable assignments that are independent from each other.
DML Statements were executed sequentially. From now on it is possible to parallelize the execution of
independent DML statements using parallel execution blocks:
BEGIN PARALLEL EXECUTION
<dml_stmt>
END;

106

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Imperative SQLScript Logic

For example in the following procedure several UPDATE statements on different tables are parallelized:
CREATE COLUMN TABLE CTAB1(A INT);
CREATE COLUMN TABLE CTAB2(A INT);
CREATE COLUMN TABLE CTAB3(A INT);
CREATE COLUMN TABLE CTAB4(A INT);
CREATE COLUMN TABLE CTAB5(A INT);
CREATE PROCEDURE ParallelUpdate AS
BEGIN
BEGIN PARALLEL EXECUTION
UPDATE CTAB1 SET A = A + 1;
UPDATE CTAB2 SET A = A + 1;
UPDATE CTAB3 SET A = A + 1;
UPDATE CTAB4 SET A = A + 1;
UPDATE CTAB5 SET A = A + 1;
END;
END;
Please note that only DML statements on column store tables are supported within the parallel execution
block. In addition, the following restrictions apply:
Modification on tables with foreign key or triggers are not allowed
Updating the same table in different statements is not allowed
Reading/Writing the same table is not allowed
All other statements (i.e. CALL, variable declarations, table assignments ) are not supported within the
parallel execution block and are blocked.
In the next example several records from a table variable are inserted into different tables in parallel.
CREATE PROCEDURE ParallelInsert (IN intab TABLE (A INT, I INT)) AS
BEGIN
DECLARE tab TABLE(A INT);
tab = SELECT t.A AS A from TAB0 t
LEFT OUTER JOIN :intab s
ON s.A = t.A;
BEGIN PARALLEL EXECUTION
SELECT * FROM :tab s where
SELECT * FROM :tab s where
SELECT * FROM :tab s where
SELECT * FROM :tab s where
SELECT * FROM :tab s where
END;
END;

SAP HANA SQLScript Reference

Imperative SQLScript Logic

s.A
s.A
s.A
s.A
s.A

=
=
=
=
=

1
2
3
4
5

INTO
INTO
INTO
INTO
INTO

CTAB1;
CTAB2;
CTAB3;
CTAB4;
CTAB5;

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

107

Calculation Engine Plan Operators

Recommendation
SAP recommends that you use SQL rather than Calculation Engine Plan Operators with SQLScript.
The execution of Calculation Engine Plan Operators currently is bound to processing within the calculation
engine and does not allow a possibility to use alternative execution engines, such as L native execution. As
most Calculation Engine Plan Operators are converted internally and treated as SQL operations, the
conversion requires multiple layers of optimizations. This can be avoided by direct SQL use. Depending on
your system configuration and the version you use, mixing Calculation Engine Plan Operators and SQL can
lead to significant performance penalties when compared to to plain SQL implementation.
Table 18: Overview: Mapping between CE_* Operators and SQL
CE Operator

CE Syntax

SQL Equivalent

CE_COLUMN_TABLE

CE_COLUMN_TABLE(<table_nam
e>[,<attributes>])

SELECT [<attributes>] FROM

<table_name>

CE_JOIN_VIEW

CE_JOIN_VIEW(<column_view_
name>[,<attributes>])

SELECT [<attributes>] FROM

<column_view_name>

out =

out = SELECT product_key,

CE_JOIN_VIEW("PRODUCT_SALE

product_text, sales FROM

S", ["PRODUCT_KEY",

product_sales;

"PRODUCT_TEXT", "SALES"]);
CE_OLAP_VIEW

CE_OLAP_VIEW
(<olap_view_name>[,<attrib
utes>])

SELECT [<attributes>] FROM

<olap_view_name>

out =

FROM OLAP_view GROUP BY

CE_OLAP_VIEW("OLAP_view",

dim1;

out = select dim1, SUM(kf)

["DIM1", SUM("KF")]);
CE_CALC_VIEW

CE_CALC_VIEW(<calc_view_na
me>,[<attributes>])

SELECT [<attributes>] FROM

<calc_view_name>

out =

out = SELECT cid, cname

CE_CALC_VIEW("TESTCECTABLE

FROM "TESTCECTABLE";

", ["CID", "CNAME"]);

108

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

CE Operator

CE Syntax

SQL Equivalent

CE_JOIN

CE_JOIN(<left_table>,<righ
t_table>,<join_attributes
>[<projection_list>])

SELECT [<projection_list>]
FROM
<left_table>,<right_table>
WHERE <join_attributes>

ot_pubs_books1 = CE_JOIN
(:lt_pubs, :it_books,

ot_pubs_books1 = SELECT

["PUBLISHER"]);

P.publisher AS publisher,
name, street,post_code,
city, country, isbn,
title, edition, year,
price, crcy FROM :lt_pubs
AS P, :it_books AS B WHERE
P.publisher = B.publisher;

CE_LEFT_OUTER_JOIN

CE_LEFT_OUTER_JOIN(<left_t
able>,<right_table>,<join_
attributes>[<projection_li
st>])

SELECT [<projection_list>]
FROM <left_table> LEFT
OUTER JOIN <right_table>
ON <join_attributes>

CE_RIGHT_OUTER_JOIN

CE_RIGHT_OUTER_JOIN(<left_
table>,<right_table>,<join
_attributes>[<projection_l
ist>])

SELECT [<projection_list>]
FROM <left_table> RIGHT
OUTER JOIN <right_table>
ON <join_attributes>

CE_PROJECTION

CE_PROJECTION(<table_varia
ble>,<projection_list>[,<f
ilter>])

SELECT <projection_list>
FROM <table_variable>
where [<filter>]

ot_books1 = CE_PROJECTION

ot_book2= SELECT title,

(:it_books,

price, crcy AS currency

["TITLE","PRICE", "CRCY"

FROM :it_b ooks WHERE

AS "CURRENCY"], '"PRICE" >

price > 50;

50');
CE_UNION_ALL

CE_UNION_ALL(<table_variab
le1>,<table_variable2>)
ot_all_books1 =
CE_UNION_ALL

SELECT * FROM
<table_variable1> UNION
ALL SELECT * FROM
<table_variable2>

(:lt_books, :it_audiobooks

ot_all_books2 = SELECT *

);

FROM :lt_books UNION ALL

SELECT *
FROM :it_audiobooks;

CE_CONVERSION

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

CE_CONVERSION(<table_varia
ble>,<conversion_params>,
[<rename_clause>])

SQL-Function
CONVERT_CURRENCY

PUBLIC
2015 SAP SE or an SAP affiliate company. All rights reserved.

109

CE Operator

CE Syntax

SQL Equivalent

CE_AGGREGATION

CE_AGGREGATION(<table_vari
able>,<aggregate_list>
[,<group_columns>])

SELECT <aggregate_list>
FROM <table_variable>
[GROUP BY <group_columns>]

ot_books1 = CE_AGGREGATION

ot_books2 = SELECT COUNT

(:it_books, [COUNT

(publisher) AS cnt, year

("PUBLISHER") AS "CNT"],

FROM :it_books GROUP BY

["YEAR"]);

year;

CE_CALC(<expr>,
<result_type>)

SQL Function

CE_CALC

TEMP = SELECT "ID" AS

TEMP =

"KEY", ROW_NUMBER() OVER

CE_PROJECTION(:table_var,

() AS "T_ID"

["ID" AS "KEY",

FROM :table_var

CE_CALC('rownum()',
INTEGER) AS "T_ID"] );
Calculation engine plan operators encapsulate data-transformation functions and can be used in the definition
of a procedure or a table user-defined function. They constitute a no longer recommended alternative to using
SQL statements. Their logic is directly implemented in the calculation engine, which is the execution
environments of SQLScript.
There are different categories of operators.
Data Source Access operators that bind a column table or a column view to a table variable.
Relational operators that allow a user to bypass the SQL processor during evaluation and to directly
interact with the calculation engine.
Special extensions that implement functions.

8.1

Data Source Access Operators

The data source access operators bind the column table or column view of a data source to a table variable for
reference by other built-in operators or statements in a SQLScript procedure.

8.1.1 CE_COLUMN_TABLE
Syntax:
CE_COLUMN_TABLE(<table_name> [<attributes>])
Syntax Elements:
<table_name>

Description

Conversion Functions

Convert between data types

float

convert arg to float type

float float(arg)

double

convert arg to double type

double double(arg)

decfloat

convert arg to decfloat type

decfloat decfloat(arg)

116

Syntax

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

Name

Description

Syntax

fixed

convert arg to fixed type

fixed fixed(arg, int, int)

string

convert arg to string type

string string(arg)

date

convert arg to date type daydate1

daydate(stringarg), daydate day

date(fixedarg)

String Functions

Functions on strings

charpos

returns the one-based position of the

nth character in a string. The string is
interpreted as using a UTF-8 character
encoding

chars

chars(string)
returns the number of characters in a
UTF-8 string. In a CESU-8 encoded
string this function returns the number
of 16-bit words utilized by the string,
just the same as if the string is en
coded using UTF-16.

strlen

returns the length of a string in bytes,

as an integer number1

int strlen(string)

midstr

returns a part of the string starting at

arg2, arg3 bytes long. arg2 is counted
from 1 (not 0) 2

string midstr(string, int, int)

leftstr

returns arg2 bytes from the left of the

arg1. If arg1 is shorter than the value of
arg2, the complete string will be re
turned. 1

string leftstr(string, int)

rightstr

returns arg2 bytes from the right of the string rightstr(string, int)
arg1. If arg1 is shorter than the value of
arg2, the complete string will be re
turned. 1

instr

returns the position of the first occur

rence of the second string within the
first string (>= 1) or 0, if the second
string is not contained in the first. 1

hextoraw

converts a hexadecimal representation string hextoraw(string)

of bytes to a string of bytes. The hexa
decimal string may contain 0-9, upper
or lowercase a-f and no spaces be
tween the two digits of a byte; spaces
between bytes are allowed.

rawtohex

string rawtohex(string)
converts a string of bytes to its hexa
decimal representation. The output will
contain only 0-9 and (upper case) A-F,
no spaces and is twice as many bytes
as the original string.

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

charpos(string, int)

int instr(string, string)

117

Name

Description

ltrim

removes a whitespace prefix from a

string. The Whitespace characters may
be specified in an optional argument.
This functions operates on raw bytes
of the UTF8-string and has no knowl
edge of multi byte codes (you may not
specify multi byte whitespace charac
ters).

string ltrim(string)

string ltrim(string, string)

removes trailing whitespace from a

string rtrim(string)

string rtrim(string, string)

removes whitespace from the begin

ning and end of a string. The following
statements are functionally:

string trim(string)

string trim(string, string)

adds whitespace to the left of a string.

A second string argument specifies the
whitespace which will be added repeat
edly until the string has reached the in
tended length. If no second string ar
gument is specified, chr(32) (' ') will be
added.

string lpad(string, int)

string lpad(string, int, string)

adds whitespace to the end of a string.

string rpad(string, int)

string rpad(string, int, string)

rtrim

trim

lpad

rpad

Mathematical Functions

118

trim(s) = ltrim(rtrim(s))

trim(s1, s2) = ltrim(rtrim(s1, s2),

s2)

Syntax

The math functions described here generally operate on floating point values;
their inputs will automatically convert to double, the output will also be a double.

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

Name

double log(double)

double exp(double)

double log10(double)

double sin(double)

double cos(double)

double tan(double)

double asin(double)

double acos(double)

double atan(double)

double sinh(double)

double cosh(double)

double floor(double)

double ceil(double)

sign

abs

Description

Syntax

These functions have the same functionality as in the Cprogramming language.

sign returns -1, 0 or 1 depending on the

sign of its argument. Sign is imple
mented for all numeric types, date, and
time.

int sign(double), etc.

int sign(date)

int sign(time)

Abs returns arg, if arg is positive or

zero, -arg else. Abs is implemented for
all numeric types and time.

int abs(int).

double abs(double)

decfloat abs(decfloat)

time abs(time)

Date Functions

Functions operating on date or time data

utctolocal

interpret datearg (a date, without time iutctolocal(datearg, timezonearg)

zone) as utc and convert it to the time
zone named by timezonearg (a string)

localtoutc

convert the local datetime datearg to

the timezone specified by the string
timezonearg, return as a date

localtoutc(datearg, timezonearg)

weekday

returns the weekday as an integer in

the range 0..6, 0 is Monday.

weekday(date)

now

returns the current date and time (lo

now()
caltime of the server timezone) as date

daysbetween

returns the number of days (integer)

between date1 and date2. This is an al
ternative to date2 - date1

daysbetween(date1, date2)

Further Functions
if

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

return arg2 if intarg is considered true if(intarg, arg2, arg3)

(not equal to zero), else return arg3.
Currently, no shortcut evaluation is im
plemented, meaning that both arg2
and arg3 are evaluated in any case.
This means you cannot use if to avoid a
divide by zero error which has the side
effect of terminating expression evalu
ation when it occurs.

119

Name

Description

case

return value1 if arg1 == cmp1, value2 if

arg1 == cmp2 etc, default if there no
match

Syntax

case(arg1, default)

case(arg1, cmp1, value1, cmp2,

value2, ..., default)

isnull

return 1 (= true), if arg1 is set to null

and null checking is on during evalua
tor run

isnull(arg1)

rownum

returns the number of the row in the

currently scanned table structure. The
first row has number 0

rownum()

1 Due

to calendar variations with dates earlier that 1582, the use of the date data type is deprecated; you

should use the daydate data type instead.

Note
date is based on the proleptic Gregorian calendar. daydate is based on the Gregorian calendar which is
also the calendar used by SAP HANA SQL.
2 These

Calculation Engine string functions operate using single byte characters. To use these functions with
multi-byte character strings please see section: Using String Functions with Multi-byte Character Encoding
below. Note, this limitation does not exist for the SQL functions of the SAP HANA database which support
Unicode encoded strings natively.

8.2.5.1

Using String Functions with Multi-byte Character

Encoding

To allow the use of the string functions of Calculation Engine with multi-byte character encoding you can use
the charpos and chars (see table above for syntax of these commands) functions. An example of this usage
for the single byte character function midstr follows below:midstr(<input_string>, charpos(<input_string>, 32), 1)

8.2.6 CE_AGGREGATION
Syntax:
CE_AGGREGATION (<var_table>, <aggregate_list> [, <group_columns>]);
Syntax elements:
<var_table>

::= :<identifier>

A variable of type table containing the data that should be aggregated.

120

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

Note
CE_AGGREGATION cannot handle tables directly as input.
<aggregate_list> ::= '['<aggregate_exp>[{, <aggregate_exp>}] ']'
Specifies a list of aggregates. For example, [SUM ("A"), MAX("B")] specifies that in the result, column "A"
has to be aggregated using the SQL aggregate SUM and for column B, the maximum value should be given.
<aggregate_exp> ::= <aggregate_func>(<aggregate_column>[AS <column_alias>])
Specifies the required aggregation expression.
<aggregate_func> ::= COUNT | SUM | MIN | MAX
Specifies the aggregation function to use. Supported aggregation functions are:
count("column")
sum("column")
min("column")
max("column")
use sum("column") / count("column") to compute the average
<aggregate_column> ::= <string_literal>
The identifier for the aggregation column.
<column_alias> ::= <string_literal>
Specifies an alias for the aggregate column.
<group_columns> ::= '['<group_column_name> [{,<group_column_name>}...]']'
Specifies an optional list of group-by attributes. For instance, ["C"] specifies that the output should be
grouped by column C. Note that the resulting schema has a column named C in which every attribute value
from the input table appears exactly once. If this list is absent the entire input table will be treated as a single
group, and the aggregate function is applied to all tuples of the table.
<group_column_name> ::= <identifier>
Specifies the name of the column attribute for the results to be grouped by.

Note
CE_AGGREGATION implicitly defines a projection: All columns that are not in the list of aggregates, or in the
group-by list, are not part of the result.
Description:
Groups the input and computes aggregates for each group.

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

121

The result schema is derived from the list of aggregates, followed by the group-by attributes. The order of the
returned columns is defined by the order of columns defined in these lists. The attribute names are:
For the aggregates, the default is the name of the attribute that is aggregated.
For instance, in the example above ([SUM("A"),MAX("B")]), the first column is called A and the second
is B.
The attributes can be renamed if the default is not appropriate.
For the group-by attributes, the attribute names are unchanged. They cannot be renamed using
CE_AGGREGATION.

Note
Note that count(*) can be achieved by doing an aggregation on any integer column; if no group-by
attributes are provided, this counts all non-null values.

8.2.7 CE_UNION_ALL
Syntax:
CE_UNION_ALL (<var_table1>, :var_table2)
Syntax elements:
<var_table1> ::= :<identifier>
<var_table2> ::= :<identifier>
Specifies the table variables to be used to form the union.
Description:
The CE_UNION_ALL function is semantically equivalent to SQL UNION ALL statement. It computes the union
of two tables which need to have identical schemas. The CE_UNION_ALL function preserves duplicates, so the
result is a table which contains all the rows from both input tables.

8.3

Special Operators

In this section we discuss operators that have no immediate counterpart in SQL.

Constant

None

The default source

unit for any kind of
conversion.

'target_unit'

Any

Constant

None

The default target

unit for any kind of
conversion.

124

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

Key

Values

Type

Mandatory

Default

Documentation

'reference_date'

Any

column containing
the target unit in
the output table.

Mandatory

Default

For ERP conversion specifically:

Table 21:
Key

Values

Type

'client'

Any

Constant

None

The client as
stored in the ta
bles.

'conversion_type'

Any

Constant

'M'

The conversion
type as stored in
the tables.

'schema'

Any

schema name

current schema

The default
schema in which
the conversion ta
bles should be
looked-up.

8.3.3 TRACE
Syntax:
TRACE(<var_input>)
Syntax elements:
<var_input>

::= :<identifier>

Identifies the SQLScript variable to be traced.

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

125

Description:
The TRACE operator is used to debug SQLScript procedures. It traces the tabular data passed as its argument
into a local temporary table and returns its input unmodified. The names of the temporary tables can be
retrieved from the SYS.SQLSCRIPT_TRACE monitoring view. See SQLSCRIPT_TRACE below.
Example:
You trace the content of variable input to a local temporary table.
out = TRACE(:input);

Note
This operator should not be used in production code as it will cause significant runtime overhead.
Additionally, the naming conventions used to store the tracing information may change. Thus, this operator
should only be used during development for debugging purposes.

Related Information
SQLSCRIPT_TRACE

126

SAP HANA SQLScript Reference

Calculation Engine Plan Operators

Procedure and Function Headers

To eliminate the dependency of having a procedure or a function that already exist when you want to create a
new procedure consuming them, you can use headers in their place.
When creating a procedure, all nested procedures that belong to that procedure must exist beforehand. If
procedure P1 calls P2 internally, then P2 must have been created earlier than P1. Otherwise, P1 creation fails
with the error message,P2 does not exist. With large application logic and no export or delivery unit available,
it can be difficult to determine the order in which the objects need to be created.
To avoid this kind of dependency problem, SAP introduces HEADERS. HEADERS allow you to create a minimum
set of metadata information that contains only the interface of the procedure or function.

Code Syntax
AS HEADER ONLY
You create a header for a procedure by using the HEADER ONLY keyword, as in the following example:

Sample Code
CREATE PROCEDURE <proc_name> [(<parameter_clause>)] AS HEADER ONLY;
With this statement you are creating a procedure <proc_name> with the given signature
<parameter_clause>. The procedure <proc_name> has no body definition and thus has no dependent base
objects. Container properties (for example, security mode, default_schema, and so on) cannot be defined
with the header definition. These are included in the body definition.
The following statement creates the procedure TEST_PROC with a scalar input INVAR and a tabular output
OUTTAB:

Sample Code
CREATE PROCEDURE TEST_PROC (IN INVAR NVARCHAR(10), OUT OUTTAB TABLE(no INT))
AS HEADER ONLY
You can create a function header similarly.

Sample Code
CREATE FUNCTION <func_name> [(<parameter_clause>)] RETURNS <return_type> AS
HEADER ONLY
By checking the is_header_only field in the system view PROCEDURE, you can verify that a procedure only
header is defined.

SAP HANA SQLScript Reference

Procedure and Function Headers

127

Sample Code
SELECT procedure_name, is_header_only from SYS.PROCEDURES
If you want to check for functions, then you need to look into the system view FUNCTIONS.
Once a header of a procedure or function is defined, other procedures or functions can refer to it in their
procedure body. Procedures containing these headers can be compiled as shown in the following example:

Sample Code
CREATE PROCEDURE OUTERPROC (OUT OUTTAB TABLE (NO INT)) LANGUAGE SQLSCRIPT
AS
BEGIN
DECLARE s INT;
s = 1;
CALL TEST_PROC (:s, outtab);
END;
As long as the procedure and/or the function contain only a header definition, they cannot be executed.
Furthermore, all procedures and functions that use this procedure or function containing headers cannot be
executed because they are all invalid.
To change this and to make a valid procedure or function from the header definition, you must replace the
header by the full container definition. Use the ALTER statement to replace the header definition of a
procedure, as follows:

Sample Code
ALTER PROCEDURE <proc_name> [(<parameter_clause>)] [LANGUAGE <lang>] [SQL
SECURITY <mode>] [DEFAULT SCHEMA <default_schema_name>][READS SQL DATA] AS
BEGIN [SEQUENTIAL EXECUTION]
<procedure_body>
END
For a function header, the task is similar, as shown in the following example:

Sample Code
ALTER FUNCTION <func_name> RETURNS <return_type> [LANGUAGE <lang>] [SQL
SECURITY <mode>][DEFAULT SCHEMA <default_schema_name>]
AS
BEGIN
<function_body>
END
For example, if you want to replace the header definition of TEST_PROC that was defined already, then the
ALTER statement might look as follows:

Sample Code
ALTER PROCEDURE TEST_PROC (IN INVAR NVARCHAR(10), OUT OUTTAB TABLE(no INT))
LANGUAGE SQLSCRIPT SQL SECURITY INVOKER READS SQL DATA
AS

128

SAP HANA SQLScript Reference

Procedure and Function Headers

BEGIN

END

DECLARE tvar TABLE (no INT, name nvarchar(10));

tvar = SELECT * FROM TAB WHERE name = :invar;
outtab = SELECT no FROM :tvar;

You cannot change the signature with the ALTER statement. If the name of the procedure or the function or
the input and output variables do not match, you will receive an error.

Note
The ALTER PROCEDURE and the ALTER FUNCTION statements are supported only for a procedure or a
function respectively, that contain a header definition.

SAP HANA SQLScript Reference

Procedure and Function Headers

129

10 HANA Spatial Support

SQLScript supports the spatial data type ST_GEOMETRY and SQL spatial functions to access and manipulate
spatial data. In addition SQLScript also supports the objective style function calls, which are needed for some
SQL spatial functions.
The next example illustrates a small scenario of using spatial data type and function in SQLScript.
The function get_distance calculates the distance between the two given parameters <first> and
<second> of type ST_GEOMETRY by using the spatial function ST_DISTANCE.
Note the : in front of the variable <first>. This needed because you are reading from the variable.
The function get_distance itself is called by the procedure nested_call. The procedure returns the
distance and the text representation of the ST_GEOMETRY variable <first>.
CREATE FUNCTION get_distance( IN first ST_GEOMETRY, IN second ST_GEOMETRY )
RETURNS distance
double
AS
BEGIN
distance = :first.st_distance(:second);
END;
CREATE PROCEDURE nested_call(
IN first ST_GEOMETRY,
IN second ST_GEOMETRY,
OUT distance double,
OUT res3 CLOB
)
AS
BEGIN
Distance = get_distance (:first, :second);
res3 = :first.st_astext();

END;

The procedure call

CALL nested_call(

first
second
distance
res3

=>
=>
=>
=>

st_geomfromtext('Point(7 48)'),
st_geomfromtext('Point(2 55)'),
?,
?);

will then return the following result:

Out(1)
Out(2)
---------------------------------------------------------------------8,602325267042627
POINT(7 48)
Note that the optional SRID (Spatial reference Identifier) parameter in SQL spatial functions is mandatory if
the function is used within SQLScript. If you not specify the SRID you will receive an error as demonstrated
with the function ST_GEOMFROMTEXT in the following example. Here SRID 0 is used which specifies the default
spatial reference system.
DO
BEGIN

130

SAP HANA SQLScript Reference

HANA Spatial Support

DECLARE arr ST_GEOMETRY ARRAY;

DECLARE line1 ST_GEOMETRY = ST_GEOMFROMTEXT('LINESTRING(1 1, 2 2, 5 5)', 0);
DECLARE line2 ST_GEOMETRY = ST_GEOMFROMTEXT('LINESTRING(1 1, 3 3, 5 5)', 0);
arr[1] = :line1;
arr[2] = :line2;
tmp2 = UNNEST(:arr) AS (A);
select A from :tmp2;
END;
If you do not use the same SRID for the ST_GEOMETRY variables <line1> and <line2> latest the UNNEST
will throw an error because it is not allowed that the values in one column have different SRID.
Besides this there is a consistency check for output table variables to ensure that all elements of a spatial
column have the same SRID.
Note that the following function are not currently not supported in SQLScript:
ST_CLUSTERID
ST_CLUSTERCENTEROID
ST_CLUSTERENVELOPE
ST_CLUSTERCONVEXHULL
ST_AsSVG
The construction of objects with the NEW keyword is also not supported in SQLScript. Instead you can use
ST_GEOMFROMTEXT(POINT(1 1), srid).
Please refer to the "SAP HANA Spatial Reference" available from the SAP HANA platform page for having
detailed information about the SQL spatial functions and their usage.

SAP HANA SQLScript Reference

HANA Spatial Support

131

System Variables

System Variables are build-in variables in SQLScript that provide you information about the current context.

11.1

::CURRENT_OBJECT_NAME
and ::CURRENT_OBJECT_SCHEMA

To identify the name of the current running procedure or function you can use the following two system
variables:
::CURRENT_OBJECT_NAME

Returns the name of the current procedure or function

::CURRENT_OBJECT_SCHEMA

Returns the name of the schema of current procedure or

function

Both return a string of type NVARCHAR(256).

The following example illustrates the usage of the system variables.
CREATE FUNCTION RETURN_NAME ()
RETURNS name
nvarchar(256),
schema_name nvarchar(256)
AS
BEGIN
name
= ::CURRENT_OBJECT_NAME;
schema_name = ::CURRENT_OBJECT_SCHEMA;
END;
By calling that function, e.g.
SELECT RETURN_NAME().schema_name, RETURN_NAME().name from dummy
the result of that function is then the name and the schema_name of the function:
SCHEMA_NAME
NAME
---------------------------------------MY_SCHEMA
RETURN_NAME
The next example shows that you can also pass the two system variables as arguments to procedure or
function call.
CREATE FUNCTION GET_FULL_QUALIFIED_NAME (schema_name nvarchar(256),name
nvarchar(256))
RETURNS fullname nvarchar(256)
AS
BEGIN
fullname = schema_name || '.' || name ;
END;

132

SAP HANA SQLScript Reference

System Variables

CREATE PROCEDURE MAIN_PROC (IN INPUT_VALUE INTEGER)

AS
BEGIN
DECLARE full_qualified_name NVARCHAR(256);
DECLARE error_text NVARCHAR(256);
full_qualified_name = get_full_qualified_name (::CURRENT_OBJECT_SCHEMA,
::CURRENT_OBJECT_NAME);

END;

IF :input_value > 1 OR :input_value < 0 THEN

SIGNAL SQL_ERROR_CODE 10000 SET MESSAGE_TEXT = 'ERROR IN '
|| :full_qualified_name || ': invalid input value ';
END IF;

Note
Note that in anonymous blocks the value of both system variables is NULL.
The two system variable will always return the schema name and the name of the procedure or function.
Creating a synonym on top of the procedure or function and calling it with the synonym will still return the
original name as shown in the next example.
We create a synonym on the RETURN_NAME function from above and will query it with the synonym:
CREATE SYNONYM SYN_FOR_FUNCTION FOR RETURN_NAME;
SELECT SYNONYM_FOR_FUNCTION().schema_name, SYNONYM_FOR_FUNCTION().name FROM
dummy;
The result is the following:
SCHEMA_NAME
NAME
-----------------------------------------------------MY_SCHEMA
RETURN_NAME

11.2

::ROWCOUNT

The System Variable ::ROWCOUNT stores the number of updated row counts of the previously executed DML
statement. There is no accumulation of all previously executed DML statements.
The next examples shows you how you can use ::ROWCOUNT in a procedure. Consider we have the following
table T:
CREATE
INSERT
INSERT
INSERT

TABLE T (NUM INT,

INTO T VALUES (1,
INTO T VALUES (2,
INTO T VALUES (1,

VAL INT);
1);
2);
2);

Now we want to update table T and want to return the number of updated rows:
CREATE PROCEDURE PROC_UPDATE (OUT updated_rows INT) AS
BEGIN
UPDATE T SET VAL = VAL + 1 WHERE VAL = 2;
updated_rows = ::ROWCOUNT;
END;

SAP HANA SQLScript Reference

System Variables

133

By calling the procedure with

CALL PROC_UPDATE (updated_rows => ?);
We get the following result back:
UPDATED_ROWS
------------------------2
In the next example we change the procedure by having two update statements and in the end we again get
the row count:
ALTER PROCEDURE
BEGIN
UPDATE T SET
UPDATE T SET
updated_rows
END;

PROC_UPDATE (OUT updated_rows INT) AS

VAL = VAL + 1 WHERE VAL = 3;
VAL = VAL + 1 WHERE VAL = 1;
= ::ROWCOUNT;

By calling the procedure you will see that the number of updated rows is now 1. That is because the las update
statements only updated one row.
UPDATED_ROWS
------------------------1
If you now want to have the number of all updated rows you have to retrieve the row count information after
each update statement and accumulate them:
ALTER PROCEDURE PROC_UPDATE (OUT updated_rows INT) AS
BEGIN
UPDATE T SET VAL = VAL + 1 WHERE VAL = 4;
updated_rows = ::ROWCOUNT;
UPDATE T SET VAL = VAL + 1 WHERE VAL = 2;
updated_rows = :updated_rows + ::ROWCOUNT;
END;
By now calling this procedure again the number of updated row is now 3:
UPDATED_ROWS
------------------------3

134

SAP HANA SQLScript Reference

System Variables

Supportability

12.1

M_ACTIVE_PROCEDURES

The view M_ACTIVE_PROCEDURES monitors all internally executed statements starting from a procedure
call. That also includes remotely executed statements.
M_ACTIVE_PROCEDURES is similar to M_ACTIVE_STATEMENTS but keeps the records of completed internal
statements until the parent procedure finishes, and shows them in hierarchical order of nested level. The
structure of M_ACTIVE_PROCEDURES looks as follows:
Table 22:
Column name

Data type

Description

PROCEDURE_HOST

VARCHAR(64)

Procedure Host

STATEMENT_STRING

NCLOB

SQL statement

STATEMENT_PARAMETERS

NCLOB

Statement parameters

STATEMENT_STATUS

VARCHAR(16)

Status of the statement:

EXECUTING: statement is still running
COMPLETED: statement is completed
COMPILING: statement will be com
piled
ABORTED: statement was aborted

STATEMENT_EXECUTION_COUNT

SAP HANA SQLScript Reference

Supportability

INTEGER

Count of statement execution

135

Column name

Data type

Description

STATEMENT_DEPTH

INTEGER

Statement depth

STATEMENT_COMPILE_TIME

BIGINT

Elapsed time for compiling statement

(mircoseconds)

STATEMENT_EXECUTION_TIME

BIGINT

Elapsed time for executing statement

(mircoseconds)

STATEMENT_START_TIME

TIMESTAMP

Statement start time

STATEMENT_END_TIME

TIMESTAMP

Statement end time

STATEMENT_CONNECTION_ID

INTEGER

Connection ID of the statement

STATEMENT_TRANSACTION_ID

INTEGER

Transaction ID of the statement

Among other things the M_ACTIVE_PROCEDURES is helpful for analyzing long running procedures and to
determine their current status. You can run the following query from another session to find more about the
status of a procedure, like MY_SCHEMA.MY_PROC in the example:
select * from M_ACTIVE_PROCEDURES where procedure_name = my_proc and
procedure_schema_name = my_schema;
There is also the INI-configuration execution_monitoring_level available to control the granularity of
monitoring level:
Table 23:
Level

Description

Disabling the feature

Full information but no values for 'STATEMENT_PARAME

TER'

Default monitoring level, full information for the monitoring

view

Intermediate status of internal statements will be traced

into indexserver trace.

Please note that you have to define the parameter in the section sqlscript.
To prevent flooding of the memory with irrelevant data, the number of records is limited. If the record count
exceeds the given threshold then the first record will be erased independent from its status. The limit can be
adjust the INI-Parameter execution_monitoring_limit, e.g. execution_monitoring_limit = 100
000.
Limitations:
No triggers and functions are supported.

136

SAP HANA SQLScript Reference

Supportability

Information other than EAPI layer is not monitored. (but might be included in the total compilation time or
execution time)

SAP HANA SQLScript Reference

Supportability

137

Best Practices for Using SQLScript

So far this document has introduced the syntax and semantics of SQLScript. This knowledge is sufficient for
mapping functional requirements to SQLScript procedures. However, besides functional correctness, nonfunctional characteristics of a program play an important role for user acceptance. For instance, one of the
most important non-functional characteristics is performance.
The following optimizations all apply to statements in SQLScript. The optimizations presented here cover how
dataflow exploits parallelism in the SAP HANA database.
Reduce Complexity of SQL Statements: Break up a complex SQL statement into many simpler ones. This
makes a SQLScript procedure easier to comprehend.
Identify Common Sub-Expressions: If you split a complex query into logical sub queries it can help the
optimizer to identify common sub expressions and to derive more efficient execution plans.
Multi-Level-Aggregation: In the special case of multi-level aggregations, SQLScript can exploit results at a
finer grouping for computing coarser aggregations and return the different granularities of groups in
distinct table variables. This could save the client the effort of reexamining the query result.
Understand the Costs of Statements: Employ the explain plan facility to investigate the performance
impact of different SQL queries.
Exploit Underlying Engine: SQLScript can exploit the specific capabilities of the OLAP- and JOIN-Engine by
relying on views modeled appropriately.
Reduce Dependencies: As SQLScript is translated into a dataflow graph, and independent paths in this
graph can be executed in parallel, reducing dependencies enables better parallelism, and thus better
performance.
Avoid Mixing Calculation Engine Plan Operators and SQL Queries: Mixing calculation engine plan operators
and SQL may lead to missed opportunities to apply optimizations as calculation engine plan operators and
SQL statements are optimized independently.
Avoid Using Cursors: Check if use of cursors can be replaced by (a flow of) SQL statements for better
opportunities for optimization and exploiting parallel execution.
Avoid Using Dynamic SQL: Executing dynamic SQL is slow because compile time checks and query
optimization must be done for every invocation of the procedure. Another related problem is security
because constructing SQL statements without proper checks of the variables used may harm security.

13.1

Reduce Complexity of SQL Statements

Best Practices: Reduce Complexity of SQL Statements

Variables in SQLScript enable you to arbitrarily break up a complex SQL statement into many simpler ones.
This makes a SQLScript procedure easier to comprehend. To illustrate this point, consider the following query:
books_per_publisher
FROM :books GROUP BY
largest_publishers =
WHERE cnt >= (SELECT

138

= SELECT publisher, COUNT (*) AS cnt

publisher;
SELECT * FROM :books_per_publisher
MAX (cnt)

SAP HANA SQLScript Reference

Best Practices for Using SQLScript

FROM :books_per_publisher);
Writing this query as a single SQL statement either requires the definition of a temporary view (using WITH) or
repeating a sub query multiple times. The two statements above break the complex query into two simpler
SQL statements that are linked via table variables. This query is much easier to comprehend because the
names of the table variables convey the meaning of the query and they also break the complex query into
smaller logical pieces.
The SQLScript compiler will combine these statements into a single query or identify the common subexpression using the table variables as hints. The resulting application program is easier to understand without
sacrificing performance.

13.2 Identify Common Sub-Expressions

Best Practices: Identify Common Sub-Expressions
The query examined in the previous sub section contained common sub-expressions. Such common subexpressions might introduce expensive repeated computation that should be avoided. For query optimizers it
is very complicated to detect common sub-expressions in SQL queries. If you break up a complex query into
logical sub queries it can help the optimizer to identify common sub-expressions and to derive more efficient
execution plans. If in doubt, you should employ the EXPLAIN plan facility for SQL statements to investigate
how the HDB treats a particular statement.

13.3 Multi-level Aggregation

Best Practices: Multi-level Aggregation
Computing multi-level aggregation can be achieved using grouping sets. The advantage of this approach is
that multiple levels of grouping can be computed in a single SQL statement.
SELECT publisher, name, year, SUM(price)
FROM :it_publishers, :it_books
WHERE publisher=pub_id AND crcy=:currency
GROUP BY GROUPING SETS ((publisher, name, year), (year))
To retrieve the different levels of aggregation the client typically has to examine the result repeatedly, for
example by filtering by NULL on the grouping attributes.
In the special case of multi-level aggregations, SQLScript can exploit results at a finer grouping for computing
coarser aggregations and return the different granularities of groups in distinct table variables. This could save
the client the effort of reexamining the query result. Consider the above multi-level aggregation expressed in
SQLScript.
books_ppy = SELECT publisher, name, year, SUM(price)
FROM :it_publishers, :it_books
WHERE publisher = pub_id AND crcy = :currency
GROUP BY publisher, name, year;
books_py = SELECT year, SUM(price)
FROM :books_ppy

SAP HANA SQLScript Reference

Best Practices for Using SQLScript

139

GROUP BY year;
It is a matter of developer choice and also the application requirements as to which alternative is the best fit
for the purpose.

13.4 Understand the Costs of Statements

It is important to keep in mind that even though the SAP HANA database is an in-memory database engine and
that the operations are fast, each operation has its associated costs and some are much more costly than
others.
As an example, calculating a UNION ALL of two result sets is cheaper than calculating a UNION of the same
result sets because of the duplicate elimination the UNION operation performs. The calculation engine plan
operator CE_UNION_ALL (and also UNION ALL) basically stacks the two input tables over each other by using
references without moving any data within the memory. Duplicate elimination as part of UNION, in contrast,
requires either sorting or hashing the data to realize the duplicate removal, and thus a materialization of data.
Various examples similar to these exist. Therefore it is important to be aware of such issues and, if possible, to
avoid these costly operations.
You can get the query plan from the view SYS.QUERY_PLANS. The view is shared by all users. Here is an
example of reading a query plan from the view.
EXPLAIN PLAN [ SET PLAN_ID = <plan_id> ] FOR <dml_stmt>
SELECT lpad(' ', level) || operator_name AS operator_name,
operator_details, object_name, subtree_cost,
input_cardinality, output_cardinality, operator_id,
parent_operator_id, level, position
FROM sys.query_plans
WHERE PLAN_ID = <plan_id> ORDER BY operator_id;
Sometimes alternative formulations of the same query can lead to faster response times. Consequently
reformulating performance critical queries and examining their plan may lead to better performance.
The SAP HANA database provides a library of application-level functions which handle frequent tasks, e.g.
currency conversions. These functions can be expensive to execute, so it makes sense to reduce the input as
much as possible prior to calling the function.

13.5 Exploit Underlying Engine

Best Practices: Exploit Underlying Engine
SQLScript can exploit the specific capabilities of the built-in functions or SQL statements. For instance, if your
data model is a star schema, it makes sense to model the data as an Analytic view. This allows the SAP HANA
database to exploit the star schema when computing joins producing much better performance.
Similarly, if the application involves complex joins, it might make sense to model the data either as an Attribute
view or a Graphical Calculation view. Again, this conveys additional information on the structure of the data
which is exploited by the SAP HANA database for computing joins. When deciding to use Graphical Calculation

140

SAP HANA SQLScript Reference

Best Practices for Using SQLScript

views involving complex joins refer to SAP note 1857202

for details on how, and under which conditions,
you may benefit from SQL Engine processing with Graphical Calculation views.
Using CE functions only, or alternatively SQL statements only, in a procedure allows for many optimizations in
the underlying database system. However when SQLScript procedures using imperative constructs are called
by other programs, for example predicates to filter data early, can no longer be applied. The performance
impact of using these constructs must be carefully analyzed when performance is critical.
Finally, note that not assigning the result of an SQL query to a table variable will return the result of this query
directly to the client as a result set. In some cases the result of the query can be streamed (or pipelined) to the
client. This can be very effective as this result does not need to be materialized on the server before it is
returned to the client.

13.6 Reduce Dependencies

Best Practices: Reduce Dependencies
One of the most important methods for speeding up processing in the SAP HANA database is a massive
parallelization of executing queries. In particular, parallelization is exploited at multiple levels of granularity:
For example, the requests of different users can be processed in parallel, and also single relational operators
within a query are executed on multiple cores in parallel. It is also possible to execute different statements of a
single SQLScript in parallel if these statements are independent of each other. Remember that SQLScript is
translated into a dataflow graph, and independent paths in this graph can be executed in parallel.
From an SQLScript developer perspective, we can support the database engine in its attempt to parallelize
execution by avoiding unnecessary dependencies between separate SQL statements, and also by using
declarative constructs if possible. The former means avoiding variable references, and the latter means
avoiding imperative features, for example cursors.

13.7 Avoid Mixing Calculation Engine Plan Operators and

SQL Queries
Best Practices: Avoid Mixing Calculation Engine Plan Operators and SQL Queries
The semantics of relational operations as used in SQL queries and calculation engine operations are different.
In the calculation engine operations will be instantiated by the query that is executed on top of the generated
data flow graph.
Therefore the query can significantly change the semantics of the data flow graph. For example consider a
calculation view that is queried using attribute publisher (but not year) that contains an aggregation node
( CE_AGGREGATION) which is defined on publisher and year. The grouping on year would be removed from
the grouping. Evidently this reduces the granularity of the grouping, and thus changes the semantics of the
model. On the other hand, in a nested SQL query containing a grouping on publisher and year this aggregationlevel would not be changed if an enclosed query only queries on publisher.
Because of the different semantics outlined above, the optimization of a mixed data flow using both types of
operations is currently limited. Hence, one should avoid mixing both types of operations in one procedure.

SAP HANA SQLScript Reference

Best Practices for Using SQLScript

141

13.8 Avoid Using Cursors

Best Practices: Avoid Using Cursors
While the use of cursors is sometime required, they imply row-at-a-time processing. As a consequence,
opportunities for optimizations by the SQL engine are missed. So you should consider replacing the use of
cursors with loops, by SQL statements as follows:

Read-Only Access
For read-only access to a cursor consider using simple selects or join:
CREATE PROCEDURE foreach_proc LANGUAGE SQLSCRIPT AS
Reads SQL DATA
BEGIN
DECLARE val decimal(34,10) = 0;
DECLARE CURSOR c_cursor1 FOR
SELECT isbn, title, price FROM books;
FOR r1 AS c_cursor1 DO
val = :val + r1.price;
END FOR;
END;
This sum can also be computed by the SQL engine:
SELECT sum(price) into val FROM books;
Computing this aggregate in the SQL engine may result in parallel execution on multiple CPUs inside the SQL
executor.

Updates and Deletes

For updates and deletes, consider using the
CREATE PROCEDURE foreach_proc LANGUAGE SQLSCRIPT AS
BEGIN
DECLARE val INT = 0;
DECLARE CURSOR c_cursor1 FOR
SELECT isbn, title, price FROM books;
FOR r1 AS c_cursor1 DO
IF r1.price > 50 THEN
DELETE FROM Books WHERE isbn = r1.isbn;
END IF;
END FOR;
END;
This delete can also be computed by the SQL engine:
DELETE FROM Books
WHERE isbn IN (SELECT isbn FROM books WHERE price > 50);

142

SAP HANA SQLScript Reference

Best Practices for Using SQLScript

Computing this in the SQL engine reduces the calls through the runtime stack of HDB and potentially benefits
from internal optimizations like buffering or parallel execution.

Insertion into Tables

CREATE PROCEDURE foreach_proc LANGUAGE SQLSCRIPT AS
BEGIN
DECLARE val INT = 0;
DECLARE CURSOR c_cursor1 FOR SELECT isbn, title, price FROM books;
FOR r1 AS c_cursor1 DO
IF r1.price > 50
THEN
INSERT INTO ExpensiveBooks VALUES(..., r1.title, ...);
END IF;
END FOR;
END;
This insertion can also be computed by the SQL engine:
SELECT ..., title, ... FROM Books WHERE price > 50
INTO ExpensiveBooks;
Similar to updates and deletes, computing this statement in the SQL engine reduces the calls through the
runtime stack of the SAP HANA database, and potentially benefits from internal optimizations like buffering or
parallel execution.

13.9 Avoid Using Dynamic SQL

Best Practices: Avoid using Dynamic SQL
Dynamic SQL is a powerful way to express application logic. It allows for constructing SQL statements at
execution time of a procedure. However, executing dynamic SQL is slow because compile time checks and
query optimization must be done for every start up of the procedure. So when there is an alternative to
dynamic SQL using variables, this should be used instead.
Another related problem is security because constructing SQL statements without proper checks of the
variables used can create a security vulnerability, for example, SQL injection. Using variables in SQL
statements prevents these problems because type checks are performed at compile time and parameters
cannot inject arbitrary SQL code.
Summarizing potential use cases for dynamic SQL are:
Table 24: Dynamic SQL Use Cases
Feature

Proposed Solution

Projected attributes

Dynamic SQL

Projected literals

SQL + variables

FROM clause

SQL + variables; result structure must remain unchanged

SAP HANA SQLScript Reference

Best Practices for Using SQLScript

143

Feature

Proposed Solution

WHERE clause attribute names & Boolean operators

APPLY_FILTER

144

SAP HANA SQLScript Reference

Best Practices for Using SQLScript

14 Developing Applications with SQLScript

This section contains information about creating applications with SQLScript for SAP HANA.

14.1 Handling Temporary Data

In this section we briefly summarize the concepts employed by the SAP HANA database for handling
temporary data.
Table Variables are used to conceptually represent tabular data in the data flow of a SQLScript procedure. This
data may or may not be materialized into internal tables during execution. This depends on the optimizations
applied to the SQLScript procedure. Their main use is to structure SQLScript logic.
Temporary Tables are tables that exist within the life time of a session. For one connection one can have
multiple sessions. In most cases disconnecting and reestablishing a connection is used to terminate a session.
The schema of global temporary tables is visible for multiple sessions. However, the data stored in this table is
private to each session. In contrast, for local temporary tables neither the schema nor the data is visible
outside the present session. In most aspects, temporary tables behave like regular column tables.
Persistent Data Structures are like sequences and are only used within a procedure call. However, sequences
are always globally defined and visible (assuming the correct privileges). For temporary usage even in the
presence of concurrent invocations of a procedure, you can invent a naming schema to avoid sequences. Such
a sequence can then be created using dynamic SQL.

14.2 SQL Query for Ranking

Ranking can be performed using a Self-Join that counts the number of items that would get the same or lower
rank. This idea is implemented in the sales statistical example below.
create table sales (product int primary key, revenue int);
select product, revenue,
(select count(*)
from sales s1 where s1.revenue <= s2.revenue) as rank
from sales s2
order by rank asc

Related Information
SAP HANA SQL and System Views Reference

SAP HANA SQLScript Reference

Developing Applications with SQLScript

145

14.3 Calling SQLScript From Clients

In this document we have discussed the syntax for creating SQLScript procedures and calling them. Besides
the SQL command console for invoking a procedure, calls to SQLScript will also be embedded into client code.
In this section we present examples how this can be done.

14.3.1 Calling SQLScript from ABAP

Using CALL DATBASE PROCEDURE

The best way to call SQLScript from ABAP is to create a procedure proxy which can be natively called from
ABAP by using the built in command CALL DATABASE PROCEDURE.
The SQLScript procedure has to be created normally in the SAP HANA Studio with the HANA Modeler. After
this a procedure proxy can be creating using the ABAP Development Tools for Eclipse. In the procedure proxy
the type mapping between ABAP and HANA data types can be adjusted. The procedure proxy is transported
normally with the ABAP transport system while the HANA procedure may be transported within a delivery unit
as a TLOGO object.
Calling the procedure in ABAP is very simple. The example below shows calling a procedure with two inputs
(one scalar, one table) and one (table) output parameter:
CALL DATABASE PROCEDURE
EXPORTING
iv_scalar =
it_table =
IMPORTING
et_table1 =

z_proxy
lv_scalar
lt_table
lt_table_res.

Using the connection clause of the CALL DATABASE PROCEDURE command, it is also possible to call a
database procedure using a secondary database connection. Please consult the ABAP help for detailed
instructions of how to use the CALL DATABASE PROCEDURE command and for the exceptions may be raised.
It is also possible to create procedure proxies with an ABAP API programmatically. Please consult the
documentation of the class CL_DBPROC_PROXY_FACTORY for more information on this topic.

Using ADBC
*&---------------------------------------------------------------------*
*& Report ZRS_NATIVE_SQLSCRIPT_CALL
*&---------------------------------------------------------------------*
*&
*&---------------------------------------------------------------------*
report zrs_native_sqlscript_call.
parameters:
con_name type dbcon-con_name default 'DEFAULT'.

146

SAP HANA SQLScript Reference

Developing Applications with SQLScript

types:
* result table structure
begin of result_t,
key
type i,
value type string,
end of result_t.
data:
* ADBC
sqlerr_ref type ref to cx_sql_exception,
con_ref type ref to cl_sql_connection,
stmt_ref type ref to cl_sql_statement,
res_ref type ref to cl_sql_result_set,
* results
result_tab type table of result_t,
row_cnt type i.
start-of-selection.
try.
con_ref = cl_sql_connection=>get_connection( con_name ).
stmt_ref = con_ref->create_statement( ).
*************************************
** Setup test and procedure
*************************************
* Create test table
try.
stmt_ref->execute_ddl( 'DROP TABLE zrs_testproc_tab' ).
catch cx_sql_exception.
endtry.
stmt_ref->execute_ddl(
'CREATE TABLE zrs_testproc_tab( key INT PRIMARY KEY, value
NVARCHAR(255) )' ).
stmt_ref->execute_update(
'INSERT INTO zrs_testproc_tab VALUES(1, ''Test value'' )' ).
* Create test procedure with one output parameter
try.
stmt_ref->execute_ddl( 'DROP PROCEDURE zrs_testproc' ).
catch cx_sql_exception.
endtry.
stmt_ref->execute_ddl(
`CREATE PROCEDURE zrs_testproc( OUT t1 zrs_testproc_tab ) ` &&
`READS SQL DATA AS ` &&
`BEGIN ` &&
`
t1 = SELECT * FROM zrs_testproc_tab; ` &&
`END`
).
*************************************
** Execution time
*************************************
perform execute_with_transfer_table.
perform execute_with_gen_temptables.
con_ref->close( ).
catch cx_sql_exception into sqlerr_ref.
perform handle_sql_exception using sqlerr_ref.
endtry.
form execute_with_transfer_table.
data lr_result type ref to data.
* Create transfer table for output parameter
* this table is used to transfer data for parameter 1 of proc zrs_testproc
* for each procedure a new transfer table has to be created
* when the procedure is executed via result view, this table is not needed
* If the procedure has more than one table type parameter, a transfer table is
needed for each parameter
* Transfer tables for input parameters have to be filled first before the call
is executed
try.
stmt_ref->execute_ddl( 'DROP TABLE zrs_testproc_p1' ).
catch cx_sql_exception.
endtry.
stmt_ref->execute_ddl(

SAP HANA SQLScript Reference

Developing Applications with SQLScript

147

'CREATE GLOBAL TEMPORARY COLUMN TABLE zrs_testproc_p1( key int, value

NVARCHAR(255) )'
).
* clear output table in session
* should be done each time before the procedure is called
stmt_ref->execute_ddl( 'TRUNCATE TABLE zrs_testproc_p1' ).
* execute procedure call
res_ref = stmt_ref->execute_query( 'CALL zrs_testproc( zrs_testproc_p1 ) WITH
OVERVIEW' ).
res_ref->close( ).
* read result for output parameter from output transfer table
res_ref = stmt_ref->execute_query( 'SELECT * FROM zrs_testproc_p1' ).
* assign internal output table
clear result_tab.
get reference of result_tab into lr_result.
res_ref->set_param_table( lr_result ).
* get the complete result set in the internal table
row_cnt = res_ref->next_package( ).
write: / 'EXECUTE WITH TRANSFER TABLE:', / 'Row count: ', row_cnt.
perform output_result.
endform.
form execute_with_gen_temptables.
* mapping between procedure output parameters
* and generated temporary tables
types:
begin of s_outparams,
param_name type string,
temptable_name type string,
end of s_outparams.
data lt_outparam type standard table of s_outparams.
data lr_outparam type ref to data.
data lr_result type ref to data.
field-symbols <ls_outparam> type s_outparams.
* call the procedure which returns the mapping between procedure parameters
* and the generated temporary tables
res_ref = stmt_ref->execute_query( 'CALL zrs_testproc(null) WITH OVERVIEW' ).
clear lt_outparam.
get reference of lt_outparam into lr_outparam.
res_ref->set_param_table( lr_outparam ).
res_ref->next_package( ).
* get the temporary table name for the parameter T1
read table lt_outparam assigning <ls_outparam>
with key param_name = 'T1'.
assert sy-subrc is initial.
* retrieve the procedure output from the generated temporary table
res_ref = stmt_ref->execute_query( 'SELECT * FROM ' && <ls_outparam>temptable_name ).
clear result_tab.
get reference of result_tab into lr_result.
res_ref->set_param_table( lr_result ).
row_cnt = res_ref->next_package( ).
write: / 'EXECUTE WITH GENERATED TEMP TABLES:', / 'Row count:', row_cnt.
perform output_result.
endform.
form handle_sql_exception
using p_sqlerr_ref type ref to cx_sql_exception.
format color col_negative.
if p_sqlerr_ref->db_error = 'X'.
write: / 'SQL error occured:', p_sqlerr_ref->sql_code, "#EC NOTEXT
/ p_sqlerr_ref->sql_message.
else.
write:
/ 'Error from DBI (details in dev-trace):',
"#EC NOTEXT
p_sqlerr_ref->internal_error.
endif.
endform.
form output_result.
write / 'Result table:'.

148

SAP HANA SQLScript Reference

Developing Applications with SQLScript

field-symbols <ls> type result_t.

loop at result_tab assigning <ls>.
write: / <ls>-key, <ls>-value.
endloop.
endform.
Output:
EXECUTE WITH TRANSFER TABLE:
Row count:
1
Result table:
1 Test value
EXECUTE WITH GENERATED TEMP TABLES:
Row count:
1
Result table_
1 Test value

14.3.2 Calling SQLScript from Java

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.CallableStatement;
import java.sql.ResultSet;

import java.sql.SQLException;CallableStatement cSt = null;

String sql = "call SqlScriptDocumentation.getSalesBooks(?,?,?,?)";
ResultSet rs = null;
Connection conn = getDBConnection(); // establish connection to database using
jdbc
try {
cSt = conn.prepareCall(sql);
if (cSt == null) {
System.out.println("error preparing call: " + sql);
return;
}
cSt.setFloat(1, 1.5f);
cSt.setString(2, "'EUR'");
cSt.setString(3, "books");
int res = cSt.executeUpdate();
System.out.println("result: " + res);
do {
rs = cSt.getResultSet();
while (rs != null && rs.next()) {
System.out.println("row: " + rs.getString(1) + ", " +
rs.getDouble(2) + ", " + rs.getString(3));
}
} while (cSt.getMoreResults());
} catch (Exception se) {
se.printStackTrace();
} finally {
if (rs != null)
rs.close();
if (cSt != null)
cSt.close();
}

SAP HANA SQLScript Reference

Developing Applications with SQLScript

149

14.3.3 Calling SQLScript from C#

Given procedure:
CREATE PROCEDURE TEST_PRO1(IN strin NVARCHAR(100), OUT SorP NVARCHAR(100))
language sqlscript AS
BEGIN
select 10 from dummy;
SorP = N'input str is ' || strin;
END;
This procedure can be called as follows:
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.Common;
using ADODB;
using System.Data.SqlClient;
namespace NetODBC
{
class Program
{
static void Main(string[] args)
{
try
{
DbConnection conn;
DbProviderFactory _DbProviderFactoryObject;
String connStr = "DRIVER={HDBODBC32};UID=SYSTEM;PWD=<password>;
SERVERNODE=<host>:<port>;DATABASE=SYSTEM";
String ProviderName = "System.Data.Odbc";
_DbProviderFactoryObject =
DbProviderFactories.GetFactory(ProviderName);
conn = _DbProviderFactoryObject.CreateConnection();
conn.ConnectionString = connStr;
conn.Open();
System.Console.WriteLine("Connect to HANA database
successfully");
DbCommand cmd = conn.CreateCommand();
//call Stored Procedure
cmd = conn.CreateCommand();
cmd.CommandText = "call SqlScriptDocumentation.scalar_proc (?)";
DbParameter inParam = cmd.CreateParameter();
inParam.Direction = ParameterDirection.Input;
inParam.Value = "asc";
cmd.Parameters.Add(inParam);
DbParameter outParam = cmd.CreateParameter();
outParam.Direction = ParameterDirection.Output;
outParam.ParameterName = "a";
outParam.DbType = DbType.Integer;
cmd.Parameters.Add(outParam);
reader = cmd.ExecuteReader();
System.Console.WriteLine("Out put parameters = " +
outParam.Value);
reader.Read();
String row1 = reader.GetString(0);
System.Console.WriteLine("row1=" + row1);
}
catch(Exception e)
{
System.Console.WriteLine("Operation failed");
System.Console.WriteLine(e.Message);
}

150

SAP HANA SQLScript Reference

Developing Applications with SQLScript

SAP HANA SQLScript Reference

Developing Applications with SQLScript

151

Appendix

15.1

Example code snippets

The examples used throughout this manual make use of various predefined code blocks. These code snippets
are presented below.

15.1.1 ins_msg_proc
This code is used in the examples in this reference manual to store outputs so the action of the examples can
be seen. It simple stores some text along with a timestamp of the entry.
Before you can use this procedure you must create the following table.
CREATE TABLE message_box (p_msg VARCHAR(200), tstamp TIMESTAMP);
You can create the procedure as follows.
CREATE PROCEDURE ins_msg_proc (p_msg VARCHAR(200)) LANGUAGE SQLSCRIPT AS
BEGIN
INSERT INTO message_box VALUES (:p_msg, CURRENT_TIMESTAMP);
END;
To view the contents of the message_box you select the messages in the table.
select * from message_box;

152

SAP HANA SQLScript Reference

Appendix

Important Disclaimer for Features in SAP

HANA Platform, Options and Capabilities

SAP HANA server software and tools can be used for several SAP HANA platform and options scenarios as
well as the respective capabilities used in these scenarios. The availability of these is based on the available
SAP HANA licenses and the SAP HANA landscape, including the type and version of the back-end systems the
SAP HANA administration and development tools are connected to. There are several types of licenses
available for SAP HANA. Depending on your SAP HANA installation license type, some of the features and
tools described in the SAP HANA platform documentation may only be available in the SAP HANA options and
capabilities, which may be released independently of an SAP HANA Platform Support Package Stack (SPS).
Although various features included in SAP HANA options and capabilities are cited in the SAP HANA platform
documentation, each SAP HANA edition governs the options and capabilities available. Based on this,
customers do not necessarily have the right to use features included in SAP HANA options and capabilities.
For customers to whom these license restrictions apply, the use of features included in SAP HANA options and
capabilities in a production system requires purchasing the corresponding software license(s) from SAP. The
documentation for the SAP HANA optional components is available in SAP Help Portal at http://
help.sap.com/hana_options. If you have additional questions about what your particular license provides, or
wish to discuss licensing features available in SAP HANA options, please contact your SAP account team
representative.

SAP HANA SQLScript Reference

Important Disclaimer for Features in SAP HANA Platform, Options and Capabilities

153

Important Disclaimers and Legal Information

Coding Samples
Any software coding and/or code lines / strings ("Code") included in this documentation are only examples and are not intended to be used in a productive system
environment. The Code is only intended to better explain and visualize the syntax and phrasing rules of certain coding. SAP does not warrant the correctness and
completeness of the Code given herein, and SAP shall not be liable for errors or damages caused by the usage of the Code, unless damages were caused by SAP
intentionally or by SAP's gross negligence.

Accessibility
The information contained in the SAP documentation represents SAP's current view of accessibility criteria as of the date of publication; it is in no way intended to be
a binding guideline on how to ensure accessibility of software products. SAP in particular disclaims any liability in relation to this document. This disclaimer, however,
does not apply in cases of wilful misconduct or gross negligence of SAP. Furthermore, this document does not result in any direct or indirect contractual obligations of
SAP.

Gender-Neutral Language
As far as possible, SAP documentation is gender neutral. Depending on the context, the reader is addressed directly with "you", or a gender-neutral noun (such as
"sales person" or "working days") is used. If when referring to members of both sexes, however, the third-person singular cannot be avoided or a gender-neutral noun
does not exist, SAP reserves the right to use the masculine form of the noun and pronoun. This is to ensure that the documentation remains comprehensible.

Internet Hyperlinks
The SAP documentation may contain hyperlinks to the Internet. These hyperlinks are intended to serve as a hint about where to find related information. SAP does
not warrant the availability and correctness of this related information or the ability of this information to serve a particular purpose. SAP shall not be liable for any
damages caused by the use of related information unless damages have been caused by SAP's gross negligence or willful misconduct. All links are categorized for
transparency (see: http://help.sap.com/disclaimer).

154

SAP HANA SQLScript Reference

Important Disclaimers and Legal Information

SAP HANA SQLScript Reference

Important Disclaimers and Legal Information

155

www.sap.com/contactsap

No part of this publication may be reproduced or transmitted in any
form or for any purpose without the express permission of SAP SE
or an SAP affiliate company. The information contained herein may
be changed without prior notice.
Some software products marketed by SAP SE and its distributors
contain proprietary software components of other software
vendors. National product specifications may vary.
These materials are provided by SAP SE or an SAP affiliate company
for informational purposes only, without representation or warranty
of any kind, and SAP or its affiliated companies shall not be liable for
errors or omissions with respect to the materials. The only
warranties for SAP or SAP affiliate company products and services
are those that are set forth in the express warranty statements
accompanying such products and services, if any. Nothing herein
should be construed as constituting an additional warranty.
SAP and other SAP products and services mentioned herein as well
as their respective logos are trademarks or registered trademarks
of SAP SE (or an SAP affiliate company) in Germany and other
countries. All other product and service names mentioned are the
trademarks of their respective companies.
Please see http://www.sap.com/corporate-en/legal/copyright/
index.epx for additional trademark information and notices.

Technical Analysis from A to Z, 2nd Edition
From Everand
Technical Analysis from A to Z, 2nd Edition
Steven B. Achelis
4.5/5 (19)
Neo4j Cypher Manual 5
No ratings yet
Neo4j Cypher Manual 5
1,017 pages
McGraw-Hill's PMP Certification Mathematics
From Everand
McGraw-Hill's PMP Certification Mathematics
Vidya Subramanian
No ratings yet
Sap Hana SQL Script Reference en PDF
No ratings yet
Sap Hana SQL Script Reference en PDF
198 pages
Netezza Stored Procedures Guide
100% (1)
Netezza Stored Procedures Guide
88 pages
Architectural Style - BlackBoard
No ratings yet
Architectural Style - BlackBoard
11 pages
SAP HANA SQL Script Reference en
100% (1)
SAP HANA SQL Script Reference en
156 pages
Sap Hana SQL Script Reference en
No ratings yet
Sap Hana SQL Script Reference en
164 pages
Sap Hana SQL Script SPS 12
No ratings yet
Sap Hana SQL Script SPS 12
164 pages
Sap Hana Sqlscript Reference (Sap Hana Platform 2.0 Sps 00)
No ratings yet
Sap Hana Sqlscript Reference (Sap Hana Platform 2.0 Sps 00)
172 pages
Sap Hana SQL Script Reference en PDF
No ratings yet
Sap Hana SQL Script Reference en PDF
138 pages
SAP HANA SQL Script Reference en PDF
No ratings yet
SAP HANA SQL Script Reference en PDF
128 pages
SAP HANA SQL Script Reference en
No ratings yet
SAP HANA SQL Script Reference en
324 pages
SAP HANA SQL Script Reference en
No ratings yet
SAP HANA SQL Script Reference en
256 pages
SAP HANA SQL Script Reference en PDF
No ratings yet
SAP HANA SQL Script Reference en PDF
256 pages
SAP HANA SQL Script Reference en
No ratings yet
SAP HANA SQL Script Reference en
328 pages
SAP HANA SQL Script Reference en
No ratings yet
SAP HANA SQL Script Reference en
328 pages
SAP HANA SQL Script Reference en PDF
No ratings yet
SAP HANA SQL Script Reference en PDF
126 pages
SAP HANA SQL Script Reference en PDF
100% (1)
SAP HANA SQL Script Reference en PDF
126 pages
Sap Hana Sqlscript Reference Sps05
No ratings yet
Sap Hana Sqlscript Reference Sps05
58 pages
Gray Hat Hacking the Ethical Hacker's
From Everand
Gray Hat Hacking the Ethical Hacker's
Çağatay Şanlı
5/5 (1)
ChatGPT for Business: Strategies for Success
From Everand
ChatGPT for Business: Strategies for Success
Matthew C. Smith
1/5 (1)
Iso-Iec 9075-4
No ratings yet
Iso-Iec 9075-4
170 pages
CNC Machining Handbook: Building, Programming, and Implementation
From Everand
CNC Machining Handbook: Building, Programming, and Implementation
Alan Overby
No ratings yet
Antenna Arraying Techniques in the Deep Space Network
From Everand
Antenna Arraying Techniques in the Deep Space Network
David H. Rogstad
No ratings yet
Iso-Iec 9075-5
No ratings yet
Iso-Iec 9075-5
261 pages
Tips & Traps for Building Decks, Patios, and Porches
From Everand
Tips & Traps for Building Decks, Patios, and Porches
R. Dodge Woodson
No ratings yet
Making Everyday Electronics Work: A Do-It-Yourself Guide: A Do-It-Yourself Guide
From Everand
Making Everyday Electronics Work: A Do-It-Yourself Guide: A Do-It-Yourself Guide
Stan Gibilisco
4/5 (2)
Introduction to Stochastic Search and Optimization: Estimation, Simulation, and Control
From Everand
Introduction to Stochastic Search and Optimization: Estimation, Simulation, and Control
James C. Spall
4/5 (2)
Enterprise PL-I For Z-OS Language Reference
No ratings yet
Enterprise PL-I For Z-OS Language Reference
596 pages
Udbsqlref
No ratings yet
Udbsqlref
1,050 pages
neo4j-cypher-manual-5
No ratings yet
neo4j-cypher-manual-5
1,044 pages
Interbase Language Reference PDF
No ratings yet
Interbase Language Reference PDF
292 pages
Netezza Stored Procedures Guide
No ratings yet
Netezza Stored Procedures Guide
88 pages
SQL Reference En
No ratings yet
SQL Reference En
2,016 pages
Dataserver For Oracle Guide
No ratings yet
Dataserver For Oracle Guide
284 pages
Computer-Aided Modeling of Reactive Systems
From Everand
Computer-Aided Modeling of Reactive Systems
Warren E. Stewart
No ratings yet
Programming the Intel Galileo: Getting Started with the Arduino -Compatible Development Board
From Everand
Programming the Intel Galileo: Getting Started with the Arduino -Compatible Development Board
Christopher Rush
5/5 (1)
Teardowns: Learn How Electronics Work by Taking Them Apart
From Everand
Teardowns: Learn How Electronics Work by Taking Them Apart
Bryan Bergeron
No ratings yet
Embedded SQL COBOL Programmers Guide en
No ratings yet
Embedded SQL COBOL Programmers Guide en
200 pages
Powerboater's Guide to Electrical Systems, Second Edition
From Everand
Powerboater's Guide to Electrical Systems, Second Edition
Edwin R. Sherman
5/5 (1)
Sqlalchemy 0 5 7
No ratings yet
Sqlalchemy 0 5 7
292 pages
Progress Embedded SQL-92 Guide and Reference
No ratings yet
Progress Embedded SQL-92 Guide and Reference
286 pages
User
No ratings yet
User
147 pages
ChatGPT CheatSheet: 400 Powerful Examples That Turn You Into a ChatGPT Expert
From Everand
ChatGPT CheatSheet: 400 Powerful Examples That Turn You Into a ChatGPT Expert
Igor Pogany
No ratings yet
Progress Book
100% (1)
Progress Book
142 pages
Ub
No ratings yet
Ub
520 pages
Tutorial
No ratings yet
Tutorial
56 pages
Large Antennas of the Deep Space Network
From Everand
Large Antennas of the Deep Space Network
William A. Imbriale
No ratings yet
SAP HANA Developer Guide For SAP HANA Web Workbench en
No ratings yet
SAP HANA Developer Guide For SAP HANA Web Workbench en
540 pages
ProgressDataServerforMSQL 1768.Sds
No ratings yet
ProgressDataServerforMSQL 1768.Sds
238 pages
Warehouse Logistic Management
From Everand
Warehouse Logistic Management
Anamelissa Montenegro Cordero
5/5 (1)
SQL Cookbook
No ratings yet
SQL Cookbook
727 pages
Quasi-Monte Carlo Methods in Finance: With Application to Optimal Asset Allocation
From Everand
Quasi-Monte Carlo Methods in Finance: With Application to Optimal Asset Allocation
Mario Rometsch
No ratings yet
GATE DA SQL_piyushwairale
No ratings yet
GATE DA SQL_piyushwairale
30 pages
Rexx
No ratings yet
Rexx
572 pages
C++/CLI: The Visual C++ Language for .NET
From Everand
C++/CLI: The Visual C++ Language for .NET
julian Pino
No ratings yet
Sqlalchemy 0 6 2
No ratings yet
Sqlalchemy 0 6 2
354 pages
SQL Anywhere Studio 9 Developers Guide
No ratings yet
SQL Anywhere Studio 9 Developers Guide
489 pages
Progress SQL 89
No ratings yet
Progress SQL 89
156 pages
The Essential Vince Lombardi: Words & Wisdom to Motivate, Inspire, and Win
From Everand
The Essential Vince Lombardi: Words & Wisdom to Motivate, Inspire, and Win
Vince Lombardi
3.5/5 (2)
What Is True About Both Synchronous and Asynchronous Remote Functions Calls
No ratings yet
What Is True About Both Synchronous and Asynchronous Remote Functions Calls
11 pages
Seven Tips For Your First Business Rules Project
No ratings yet
Seven Tips For Your First Business Rules Project
8 pages
BRF
No ratings yet
BRF
25 pages
Movimentos Localizados Brasil
100% (1)
Movimentos Localizados Brasil
2 pages
IBM Lotus Symphony Developer's Guide
No ratings yet
IBM Lotus Symphony Developer's Guide
150 pages
Mark McKinnon - Plug Me in Renzik, Autopsy Plugins Now and in The Future
No ratings yet
Mark McKinnon - Plug Me in Renzik, Autopsy Plugins Now and in The Future
45 pages
Kod Za Android Aplikaciju
No ratings yet
Kod Za Android Aplikaciju
12 pages
Jamila Bombaywala: US Work Authorization - Legal Permanent Resident (Green Card)
No ratings yet
Jamila Bombaywala: US Work Authorization - Legal Permanent Resident (Green Card)
2 pages
Spru 433 J
No ratings yet
Spru 433 J
317 pages
Beginning Google Maps API PDF
No ratings yet
Beginning Google Maps API PDF
5 pages
POM and Page Factory in Selenium Best Approach For Script Maintenance
No ratings yet
POM and Page Factory in Selenium Best Approach For Script Maintenance
19 pages
CMPUT 175 Lecture #4
No ratings yet
CMPUT 175 Lecture #4
26 pages
Ksenmp
No ratings yet
Ksenmp
17 pages
CIS Apple macOS 10.15 Benchmark v1.1.0 PDF
No ratings yet
CIS Apple macOS 10.15 Benchmark v1.1.0 PDF
289 pages
Ch07 Testing
No ratings yet
Ch07 Testing
30 pages
A Blueprint For SAP Deployment From HPE and Red Hat - 1617310212988001wyTR
No ratings yet
A Blueprint For SAP Deployment From HPE and Red Hat - 1617310212988001wyTR
13 pages
Unit 2
No ratings yet
Unit 2
7 pages
Lab 14
No ratings yet
Lab 14
20 pages
Arduino 3X3 LED Random
No ratings yet
Arduino 3X3 LED Random
5 pages
Security Challenges Posed by Mobile Devices
No ratings yet
Security Challenges Posed by Mobile Devices
9 pages
SIT232 Programming Project 1
No ratings yet
SIT232 Programming Project 1
10 pages
VU Quiz Firewall Bypass (VUBuddy)_ a.I Quiz Solver & One-Click Lecture Skip
No ratings yet
VU Quiz Firewall Bypass (VUBuddy)_ a.I Quiz Solver & One-Click Lecture Skip
4 pages
Dsu 15
No ratings yet
Dsu 15
3 pages
Choosing Swing or HTML - Universal Robots
No ratings yet
Choosing Swing or HTML - Universal Robots
5 pages
MicroFrontends Final Guide
No ratings yet
MicroFrontends Final Guide
27 pages
IT3204: Fundamentals of Software Engineering
No ratings yet
IT3204: Fundamentals of Software Engineering
8 pages
30 Top Node - Js Interview Questions and Answers (Most Popular)
No ratings yet
30 Top Node - Js Interview Questions and Answers (Most Popular)
2 pages
Content Page - Cict Thesis Manuscript Template
No ratings yet
Content Page - Cict Thesis Manuscript Template
19 pages
Arrays and Pointers in C: Alan L. Cox Alc@rice - Edu
No ratings yet
Arrays and Pointers in C: Alan L. Cox Alc@rice - Edu
26 pages
ANSWERS to c++ Hose Exam Oct 2024
No ratings yet
ANSWERS to c++ Hose Exam Oct 2024
9 pages
MAD Chapter 1
No ratings yet
MAD Chapter 1
2 pages
Autolisp Notes
No ratings yet
Autolisp Notes
53 pages
Full Unit 1 Notes-KCS-102
No ratings yet
Full Unit 1 Notes-KCS-102
44 pages