openSAP

Next Steps in Software Development on SAP

HANA
WEEK 1, UNIT 1
00:00:13

Welcome to this new openSAP course: Next Steps in Software Development on SAP HANA.

00:00:19

My name is Thomas Jung and I'm a director, SAP HANA product management.

00:00:23

I'm Rich Heilman, senior product manager, SAP HANA.

00:00:27

We'll be the instructors for this course.

00:00:30

And whether you're new to development on SAP HANA

00:00:36

or whether maybe you attended the first course in this openSAP series,

00:00:41

I think you will find that there's lots of new information and

00:00:46

intermediate and advanced techniques when it comes to doing native development in SAP
HANA.

00:00:51

And that's really what we're going to cover over the next six weeks' worth of material,

00:00:56

which will comprise recorded lectures, demos, and exercises, with evaluations at the end of
each week.

00:01:07

And then in the seventh week, there will be a final exam where you can accumulate points
from the various tests that will take place

00:01:17

and get a record of achievement.

00:01:20

Now in this, week 1, unit 1, we want to do a little bit of introduction to the course in general,

00:01:26

but also do a little bit of a review on the general architecture of HANA

00:01:33

and particularly HANA native development.

00:01:38

So this first slide shows us a little bit of a review, as we said.

00:01:42

Some of the materials here may be review from the previous course,

00:01:49

but necessary to jump everybody back in.

00:01:52

This slide is a little busy,

00:01:55

but it does a good job of demonstrating that HANA has evolved to be so much more than just a
database.

00:02:01

In the beginning, we were really focused on HANA as a very fast, in-memory database

00:02:06

for both analytic and transactional processing.

00:02:10

Of course, that's very much the core, the heart, of what HANA still remains.

00:02:15

But over time, as HANA is used in more and more scenarios, we've begun to build out
additional capabilities around HANA.

00:02:23

A couple of these will be really key to what we're talking about in this course,

00:02:28

particularly the application services we'll talk more about in just a second.

00:02:34

But you see all these other capabilities as well.

00:02:37

Text-processing capabilities. Predictive analytics.

00:02:41

Geospacial capabilities. Interaction with other scenarios, like Hadoop integration.

00:02:47

We'll touch on a few of these scenarios as well as they relate to doing application development
on SAP HANA.

00:02:56

Now the real core of what enables a lot of what we're going to talk about in this course

00:03:01

is something that we call the SAP HANA extended application services, or XS for short.

00:03:09

Something referred to as XS Engine.

00:03:12

Now the origins of this really go back to the beginnings of HANA

00:03:17

and take advantage of the in-memory processing and the speed of SAP HANA.

00:03:24

We were rewriting applications and optimizing them for HANA,

00:03:29

meaning doing as much as we can in SQL and down in the database,

00:03:34

maybe taking advantage of things like SQLScript, which we'll talk about in week 3,

00:03:39

views, which we'll talk about in week 2.

00:03:41

But as we built applications in this design, doing what we call code pushdown to do as much of
the processing in the database as possible,

00:03:50

we really saw an opportunity there

00:03:53

that more and more of the complete application could be developed in the database itself.

00:04:00

Seems like a little bit of a shame to have to then introduce an external application server and
Web server

00:04:07

if that was only doing a very small portion of the overall processing.

00:04:11

So the idea was to take the already powerful capabilities and development functionality in the
HANA core itself

00:04:20

to utilize SQL and SQLScript and views and add to that an embedded application server and
Web server.

00:04:29

And this is what really enables what we call HANA native development.

00:04:32

Meaning that you do the complete application development from end to end,

00:04:37

everything from the screens to the service enablement to the business logic, the data-intensive
logic,

00:04:45

all of that is done inside of HANA. The development is done inside of HANA and the execution
takes place inside of HANA.

00:04:53

And when we added this application server, we didn't just install another application server on
the operating system of the HANA appliance.

00:05:02

We really integrated something deeply inside of the HANA architecture itself.

00:05:09

And the name here, the XS that has stuck around, the acronym, really originally stood for
extra small,

00:05:16

when we were designing and building this inside of SAP.

00:05:20

So there are some major architectural differences than maybe what you're used to

00:05:24

with a traditional application serverdatabase combination.

00:05:28

This application server is very small.

00:05:30

It's designed to be completely stateless. Really just for pass-through logic, a little bit of
validation, a little bit of service enablement.

00:05:40

So in the end, as this slide shows, the general flow of the development process is broken down
into multiple parts.

00:05:49

We have our presentation logic. This should be completely UI5

00:05:58

we call it SAPUI5completely HTML5-based

00:06:03

so that you're creating HTML files, JavaScript files, cascading style sheets,

00:06:09

and then the HANA database is just serving those out so that the presentation logic can
execute completely on the client side.

00:06:17

Then this presentation logic that's executing either in the Web browser or in the mobile
device...

00:06:22

when it needs data or it needs logic to be executed on the server,

00:06:27

it will make service calls, RESTful service calls to call back to the server.

00:06:32

And in particular, we use OData services there.

00:06:36

And that's where the control flow logic and the service enablement logic of this middle tier,

00:06:41

this middle part of HANA, this HANA extended application services, it can execute.

00:06:48

And then or course we have all our calculation logic, our data-intensive logic, that's down in the
database itself.

00:06:56

The development artifacts that we'll be working with over the course of this openSAP course
are shown here on this slide.

00:07:06

So starting from the top, when we talk about the UI rendering, you'll use SAPUI5.

00:07:13

That's our HTML5 library based upon open source, where you see jQuery and jQuery Mobile
as part of SAPUI5.

00:07:23

In addition there, we have UI Integration Services.

00:07:27

This is a lightweight, almost a portal page-building framework.

00:07:34

We'll use both of these technologies a little later in the course as we start building services and
then putting user interfaces on top of it.

00:07:41

We'll use a lot of SAPUI5.

00:07:44

At the very end of the course, we'll use UI Integration Services to show you how you can build

a Fiori dashboard as well.

00:07:53

Next, we have the server-side procedural logic.

00:07:58

For that, we primarily use JavaScript.

00:08:01

So that is the application server itself. It is a JavaScript Virtual Machine.

00:08:06

And what we did is we took an open-source JavaScript VM, Mozilla SpiderMonkey,

00:08:13

the same JavaScript VM that runs inside of Firefox.

00:08:18

And that's what we use on the server side.

00:08:20

That allows a lot of openness and a lot of reuse of existing code, since

00:08:24

any standard strict-mode-compliant JavaScript will then run on this server side.

00:08:31

In addition to the general server side programming, what we call XSJS, we also have some
specialized service frameworks.

00:08:40

The one that we're really going to focus on in this course is the XSODATA.

00:08:44

XSODATA allows you to create OData services for both read and create update delete
operations

00:08:53

very quickly, very easily, with a minimal amount of coding.

00:08:58

We'll have a whole week in the course on the use of the OData services.

00:09:03

And then we have all the lower-level artifacts.

00:09:07

Of course HANA is an ANSI SQL-compatible database. You have the ability to create a table
or create a view using just SQL commands.

00:09:18

But we also wanted the ability to manage the life cycle on those types of development objects,

00:09:26

as well as have a higher-level syntax to ease the development of things like tables and views.

00:09:34

Therefore, we have the ability to store all those development artifacts as a separate designtime object,

00:09:41

and to store those design-time definitions in the HANA repository.

00:09:46

The HANA repository is simply a source code repository for all the development artifacts
everything from schemas and tables

00:09:54

to the services to the JavaScript logic to your user interface definition

00:09:59

but store all that in the HANA database itself, in memory,

00:10:04

but also things like version management and

00:10:09

all the software lifecycle management capabilities of source control that you would expect are
all built into HANA as well.

00:10:16

So we'll see this complete process from end to end, where we start with the lower level and we
create our tables and our views.

00:10:22

We'll put SQLScript and HANA modeled views on top of that.

00:10:28

We'll service-enable our logic, and we'll build user interfaces for it throughout this course.

00:10:35

Now just a little bit more on the architecture and how it is very different than the traditional
three-tiered application server architecture.

00:10:44

In that traditional architecture, the application server is how you do your scalability and it's
really the focus of the programming model.

00:10:53

Here we shrink the role of the application server and embed it inside of the database.

00:10:59

Now you're going to do all of your scaling simply by making sure that your database is large
enough to handle the concurrent queries that will take place.

00:11:06

And the little bit of overhead that's needed for service enablement, authentication, and just
general Web serving,

00:11:14

is really built into the base sizing of the HANA system itself.

00:11:18

And what this does is it simplifies both the design-time process, the fact that we can put all of
the development artifacts in the HANA database itself,

00:11:26

it simplifies the runtime and the deployment of the applications,

00:11:30

and overall reduces the cost of ownership while at the same time giving an opportunity for
performance

00:11:38

that you wouldn't have with the traditional three-tiered architecture.

00:11:41

Because here the application server understands the HANA native data types.

00:11:45

It's embedded inside the database processing, so we don't have to transform the data as it
moves between the database layer and the application server layer.

00:11:54

So as you'll see in this course, there are a lot of benefits to following this native development
approach.

00:12:01

The traditional three-tiered architecture is still a viable option and something that we absolutely
still do at SAP.

00:12:08

Look at the Business Suite. It still largely uses the ABAP Application Server.

00:12:13

There's certainly use cases where you would use Java or .NET application servers.

00:12:18

But in these scenarios, the application server is completely separate from the database,

00:12:22

often running on a completely separate machine.

00:12:25

It must communicate to the database using ODBC, JDBC, or some other standard database
interface.

00:12:33

And of course, the data then has to move between the app server and the database server.

00:12:37

And once again, in this scenario, the focus of the programming model is heavily on the
application server.

00:12:44

You do most of your scaling and load balancing and things like that at the application-server
level.

00:12:50

So it creates a very different architectural design. These are just things you need to keep in
mind

00:12:56

as you begin to design your applications for HANA native development instead.

00:13:01

Finally, some of the highlights of what we'll cover in this course.

00:13:06

As I said earlier, you may have already taken the introduction course, where we would have
covered many of the basics.

00:13:12

In this course, we will not always re-cover the basics.

00:13:16

This gives us the opportunity to jump right in on many of the topics

00:13:21

and go right to intermediate level or advanced capabilities

00:13:25

or new features that have been introduced since we did the first course.

00:13:30

As we'll talk about a little bit later, the exercise that you will do will have all the basic exercises
from the first course

00:13:37

as well as the new exercises for this course.

00:13:40

So it will still give you a chance if you need a little refresher, you will get it as you go along
through the exercises.

00:13:46

But some of the things that we will cover in this course.

00:13:49

We will cover the new syntax for Core Data Services, a way of defining database artifacts,

00:13:57

not just tables but also table types and views. And that will continue to expand over time.

00:14:03

We'll look at some advanced modeling techniques. In the first course we looked at basic
attribute analytic views.

00:14:09

In this course we'll look at decision tables and scripted and graphical calculation views.

00:14:16

We'll cover advanced SQLScript techniques.

00:14:20

In the XSODATA section, we'll go beyond the basics and look at the create update delete
operations as well,

00:14:28

and how you can use exits, and batch operations.

00:14:33

For the server-side JavaScript, we will look at just some core usage of the JavaScript
language, something we didn't go deep into in the first course,

00:14:42

but now we have the opportunity to talk about JavaScript in general and how you can get more
value out of the language itself.

00:14:49

We'll also look at how we can use the new capabilities of outbound HTTP calls.

00:14:55

We also have new capabilities for job scheduling in the XS layer. So we will cover that as well.

00:15:02

We will use SAPUI5 pretty heavily because as we build services both in OData and in serverside JavaScript,

00:15:10

we will test those by building little SAPUI5 user interfaces on top of that.

00:15:17

And then toward the end of the course, we will cover some more advanced techniques in
SAPUI5

00:15:21

and take a look at Fiori and show you how you can build a Fiori launchpad application.

00:15:27

Then in the last week, we will look at a general assortment of topics that will cover general
lifecycle management.

00:15:35

We'll look at the newer text analysis and search capabilities of HANA, as well as geospacial
capabilities.

00:15:44

So I hope you'll join us for the rest of the weeks and units as we go through this.

00:15:47

We'll be back in the next unit looking a little deeper into reviewing some of the architecture of
SAP HANA.

WEEK 1, UNIT 2
00:00:13

Welcome back to Week 1, Unit 2, Exercise System Setup.

00:00:18

So, in this unit, we want to talk to you about all the details which you need to get started

00:00:24

with the system that we provide for you to do the exercises that go along with this course.

00:00:30

We also want to talk to you a little bit about the demo model and the example implementations
that we've already installed in the system.

00:00:39

And then talk a little bit about the exercise document itself that you are going to be working
with.

00:00:47

So, first of all, for this course what we've decided to make available is to just use the standard
SAP HANA Developer Edition.

00:00:56

So, you should be able to go out to the SAP HANA Developer Center on the SAP Community
Network

00:01:03

the URL is listed on the slide and you'll be able to go sign up for the SAP HANA Developer
Edition.

00:01:10

So, I just go ahead and pull up the site that we're talking about here.

00:01:15

So, you would come to the Developer Center, the HANA section of the Developer Center,

00:01:19

and then you're able to come here to the SAP HANA Developer Edition and just say Start
Here.

00:01:25

And what you'll see is we're not going to go through the whole process of showing you how
to sign up

00:01:31

I imagine many of you watching this course already have signed up for the Developer Edition.

00:01:37

But they've done a really nice job of documenting all the steps, walking you through it, really
very step-by-step.

00:01:45

And you can see, if you want to, see the Step-by-step Guide.

00:01:49

It's got screen shots of how you sign up with an account if you don't already have one with
Amazon or Microsoft Azure.

00:01:56

And then how you can walk through the process of allocating a system.

00:02:00

Now, part of the reason that we're choosing the Developer Center is that we've already
preinstalled all of our content unto the Developer Center image.

00:02:08

So all the templates, all the demo model, the exercise web site that we're going to use for
templates,

00:02:16

it's all already available on this Developer Center image.

00:02:21

In fact, all the content from the first course that we did on HANA native development is already
installed and available in the Developer Center image.

00:02:30

Now, if you have an older version of the Developer Center image, I encourage you to go out to
the web site,

00:02:37

make sure that you have an up-to-date version. You might have to get a newer version or
update your version so you have all of this content

00:02:45

but this will be the only way that will support people doing these exercises on the forms,

00:02:53

make a downloadable version of the content available that you can install in your own system

00:02:59

but that's done without support. You have to have a pretty consistent base to work from in
order to be able to support it.

00:03:05

So the Developer Center is our main way of offering you all the content, and an environment
that we know.

00:03:12

You know, we already tested all the exercises in it, you know,

00:03:15

we know that release level will work with all the examples and all the techniques that we are
going to be showing you.

00:03:24

Now, all of our demo content that we will be doing throughout our six weeks,

00:03:28

and all of the exercise material we leverage, leveraging something that we call the SHINE,
SAP HANA Interactive Education content.

00:03:35

So you can find this in your systems that you have, that you get from the Developer Center.

00:03:40

And this is underneath the package hierarchy sap/hana/democontent/epm,

00:03:48

or for our new contents under the epmNext package.

00:03:52

So, the goal of this is to basically give you a baseline model to work from

00:03:57

so you don't have to create your own tables and have your own data.

00:04:00

Basically we give you the tables, the data, some examples of how to build various artifacts on
top of those artifacts

00:04:10

and it allows you to get right into the system and start developing very quickly.

00:04:16

So we can take a quick look at that. So, I already have a package or project pulled down from
the system.

00:04:25

So, you can see the epmNext project here, and I have various folders within this project.

00:04:31

So underneath the data folder, I have all of the artifacts related to the Data Dictionary objects.

00:04:37

such as hdbdd files, which is to coordinate the services, hdbsequences, and I have
hdbschemas in here as well.

00:04:47

All these types of artifacts you will create in week 2.

00:04:53

Also have various other types of artifacts within those projects.

00:04:57

Under functions, I have things like scalar and table functions that we will talk about in week 3,
as well as several procedures.

00:05:06

And again, all the demos and all the exercises that you will do throughout the entire course

00:05:11

all of the examples are here in working order so you could very easily switch over to this
project,

00:05:19

run any of these examples that you want at any given time.

00:05:23

Just a few other ones here. We have all the models that you will see in the modelling section
that we will take a look at.

00:05:32

As well as any of the services. There are OData services as well as the XSJS services.

00:05:39

All of these are documented here and runnable.

00:05:43

And then we have all of the SAPUI5 applications sorted here as well.

00:05:52

So again, any of the content that you see us doing throughout all the weeks and any of the
content you do in the exercises

00:05:57

is here for you installed already in the system that you will get from the Developer Center.

00:06:02

So, this just reviews there is a slide in here showing you much of what Rich just showed you
in the system.

00:06:07

Just give me a little highlight of everything we are going through, and actually I think you will
find that

00:06:12

in the SHINE content you will even find demos that we don't have exercises for.

00:06:17

So, there's even more content than what we cover in all the exercises in this course.

00:06:21

So, it's designed to be a learn-on-your-own page by studying examples and source code kind
of tool.

00:06:28

This is also be the data model that we will be using. We will be working with this purchase
order.

00:06:33

Primarily purchase orders and business partners. I think even if you weren't that familiar with
ERP,

00:06:39

purchase orders and sales orders and things like that, employees that is something that we
can all pretty easily understand.

00:06:44

So, it's a simplified data model but yet it has enough fields and enough relationships to be
interesting.

00:06:51

Now, the final part of this is an exercise document. So what we have is a Word document.

00:06:58

We are really with the Word format. You will get a PDF document.

00:07:01

But it's broken down to follow the structure of the course. So what you will see here, there's
major sections

00:07:08

that correspond to the weeks and the units that have system exercises to go along with them.

00:07:14

Inside each of these, we always start off with one page that will describe what you are going to
be doing in this week or unit.

00:07:22

So, just from a very high level saying, now you are going to go create a project

00:07:26

or now you are going to create a service that does this.

00:07:30

But then, in the subsequent steps it really shows you completely step-by-step exactly what to
do and what to type.

00:07:39

It has links to where you can go to get the templates because there are many times that there
are source code templates

00:07:47

so you can cut and paste, so you not having to retype everything

00:07:51

or watch the videos and pause them and type from them. The idea is this document, you know,

10

00:07:55

you can watch the videos to get a high level understanding of how to do the exercises

00:07:58

but then really you go this document to follow along doing these exercises in a system.

00:08:05

The other thing that I want to point out here is that in many cases, if you look at this structure
here,

00:08:11

now let me just go ahead and look at, let's say, Week 2 Unit 4.

00:08:16

What we've included in Week 2 Unit 4, for instance, you have Creating an Attribute View and
Creating an Analytic View.

00:08:23

That was actually from the introductory course. And then we have the new exercises that are
part of this intermediate advance course

00:08:34

for creating a decision table, a calculation view, and a graphical calculation view.

00:08:39

Now when we do our demos, we are only going to show you the new exercises.

00:08:42

You can of course go back to the first course and watch the videos of the previous exercise.

00:08:46

But what we want to do is give you all the exercises from both courses in line of this document.

00:08:51

So you can really see the complete flow and it keeps us from having to repeat a lot of the basic
steps, you know.

00:08:58

How to create a project, and how to create a procedure. We can jump right in to the advanced
techniques.

00:09:03

You can still do all the steps, and maybe you didn't even go to the first course.

00:09:07

Maybe you've learned the basics on your own or by studying the help documentation, or
whatever.

00:09:13

And this makes for a nice review so that we're all on the same page when we start getting into
some of the more advanced topics.

00:09:24

So that really takes us through to the end of this week.

00:09:30

Now we are going to be able to get into the system and get started using some of these tools
in the subsequent units in this week.

11

WEEK 1, UNIT 3
00:00:12

Okay, welcome back to Week 1. This is Unit 3.

00:00:16

Well talk a little bit about the XS Administration Tool and access control topics.

00:00:21

So, there is two types of files that we knew when we create an application in HANA.

00:00:28

One is the application describer file or the .xsapp file which really controls the access to that
particular package within the system.

00:00:39

So it marks the web content root of your application.

00:00:44

So this is a must-have. You must have this file in order for your applications to be exposed to
the outside.

00:00:52

So, you also have the application access file, which is .xsaccess which exposes the web
content and sets allows you to set the authentication method and other types of
configuration as well.

00:01:10

We also have a new administration tool which allows you to customize or do additional
configuration to the xsaccess file.

00:01:20

So, lets just say, for example, SAP ships an application with a standard .xsaccess file and you
want to overwrite some of those particular configuration settings.

00:01:33

You can do this with the administration tool.

00:01:38

So, lets go ahead and take a look in the system. And first, lets take a look at the .xsaccess
that we have in the SHINE content, in epmNEXT.

00:01:48

You can see here, I have several configuration settings done here. One is the exposed value
here.

00:01:56

If I want it to hide a particular application for a period of time, I can switch this to force.

00:02:03

And that would make that application not available.

00:02:06

We also have an authentication item here which controls how the user authenticates to the
application.

00:02:13

Whether itd be a log-on ticket or a basic authentication or a form-based authentication which

gives the end user a log-on screen, a web page.

00:02:25

We also have an authorization tag here which allows you to leverage xsprivilege files

00:02:33

as well as things like prevent_xsrf which well talk about later in the, in one of the subsequent
weeks.

00:02:43

So, lets take a look at the admin tool.

00:02:48

So, the admin tool here allows me to, again, overwrite some particular configuration within the
.xsaccess file without actually modifying that file.

00:02:59

So this configuration that is done here is actually stored within the database in a set of
configuration tables as opposed to overwriting or changing the .xsaccess file itself.

00:03:13

And, for example, lets just say, over here, I want to force SSL or change this configuration
option.

00:03:20

I have to go over here and click this pencil. And that signifies its changed to an X now, and

12

that signifies that this particular configuration item is being overwritten,

00:03:33

not necessarily that I have to check it on and off here is what changes it but that is the actual
value, so the X over here actually shows that the value is being overwritten.

00:03:42

And in this case it is showing as a blank here but I can, of course, change this to a check mark.

00:03:51

Also on the Authentication here, we have several different authentication types that we
support.

00:03:58

So say for example, we want to overwrite this. We could simply choose X509 sorry, click the
pencil and choose X509.

00:04:07

And click Save and then this would overwrite any configuration that was done in the xsaccess
file itself.

00:04:16

Id probably add there, that we also see some of the more advanced authentication
techniques, and the other thing the XS Admin Tool does is not necessarily a developer feature

00:04:27

but if you come over here you can see that for administrators this is also where they would go
to set up the Trust Manager to import certificates and to do the same old configuration.

00:04:37

So for the more advanced authentication techniques you need more options than the ones you
can just set in an xsaccess file.

00:04:45

And this is also the tool that where you do that. Just make everyone aware, like I said, more of
a system admin type activity but this is where its done as well.

00:05:00

So again, some additional features with regards to the administration tool. Well talk about
several of these as we move forward in the various weeks.

00:05:09

Anonymous connections, cache control, cross-site request forgery or XSRF, MIME mapping,
rewrite rules, application authorization.

00:05:19

And we are not going to cover everything thats possible within this configuration, within the
xsaccess or the admin tool for that manner.

00:05:28

But all these types of things are documented fully in the Developer Guide which you can find at
help.SAP.com.

00:05:36

Thanks for joining us for Unit 3.

13

WEEK 1, UNIT 4
00:00:12

Welcome back to Week 1, Unit 4. In this unit we want to talk more about some of the new
tooling that we have in SAP HANA native development.

00:00:22

Specifically the HANA Application Lifecycle Management tool and how that we can do
application lifecycle management in general.

00:00:30

So, this is usually the tool where you would start when you have a whole new project. So
appropriate, since we are going to start into our exercises here soon.

00:00:39

Well go ahead and will use what well learn from this unit to be able to start our exercise
project.

00:00:46

Now first of all, in general, lets talk about application lifecycle management. What do we mean
by that?

00:00:53

When we refer to application lifecycle management we really mean the process of transporting
your changes between your different types of HANA systems.

00:01:02

So, you probably have a HANA development system and maybe you have another system,
thats your quality assurance or your test system and then finally you have your productive
system.

00:01:13

You make all of your changes in your development system and then when they get to a point
where developers finished with them

00:01:19

you transport them to some intermediate system, a test system of some sort,

00:01:25

so that those changes can be tested along with other changes in the system and maybe tested
on top of a little more realistic data sets.

00:01:34

Then finally, the changes are propagated to production.

00:01:39

Now, we have some techniques and some ways of grouping things together to make this
lifecycle management easier.

00:01:47

First of all, as you change anything in the HANA system, its really its making all those
changes in the repository.

00:01:54

We talked about that in the first unit, the fact that the HANA database itself is a source code
control system

00:02:00

and that all the versions of all of your design-time artifacts are stored in the database.

00:02:06

And at any time you can say I want to take others views, the procedures, or whether thats
Java script code, service definitions, or a user interface

00:02:17

you can transport that to another system.

00:02:19

Now, we dont want to do that at individual file level when we want to say, now transport this
view and transport this We want to be able to group things together.

00:02:28

And the way that we do that is with packages.

00:02:31

So, when we look at the HANA repository although all the content is just stored in database
tables

00:02:38

what we do to make it a little more usable from a source code management stand point is in all
the tooling we show that as folders and files.

14

00:02:48

So, the development artifacts themselves are files and then the folder structure is really these
packages.

00:02:55

A package is a way of grouping development objects together. It also serves as a name space

00:03:01

as many the development artifacts will use the package path as the beginning part of the name
of that development object.

00:03:08

For instance, when you create a new table using the repository approach, it will take the
package path and append that on the front of the table name.

00:03:16

That way you could have I could create a table named demo1, Rich can create a table
named demo1.

00:03:22

As long as we put them in different packages were not going to have any problems theyre
still be uniquely named.

00:03:30

So, the package is the main way of grouping our content together.

00:03:35

And often when we create a project, well have a root package for that project, and then well
create sub-packages.

00:03:42

Now, it doesnt really matter what you name your sub-packages. That doesnt control anything
from any sort of technical way in the system.

00:03:51

As a best use case, we at SAP often will group objects of a certain type together like when
Rich showed you already the SHINE content with the data package.

00:04:01

And that had all the data definitions, and then there is a models package and there is a UI
package.

00:04:07

Theres nothing enforcing that says you have to put objects in those packages.

00:04:11

It just is nicer from a usage standpoint and also from a documentation standpoint.

00:04:16

So really, its as though youre creating a share folder on a file system. You do what makes the
most sense for your organization.

00:04:24

And probably the most important aspect of that is simply being consistent.

00:04:28

Now, when it comes time to actually move content from one system into another, we need to
assign one or more packages to a delivery unit.

00:04:38

And as actually the delivery unit is what we will be transporting, we will export and import
delivery units out of one system and into another.

00:04:48

Now, in the beginning of the development process were probably not that concerned with
delivery units.

00:04:52

We are going to start off by creating our packages and our project.

00:04:56

And when were done with all of our development only then will we assign it to a delivery unit.

00:05:01

So for the purpose of this course today in this unit, we will create our initial package and our
project and everything we need to get started.

00:05:10

But we then we wont assign all this to a delivery unit until Week 6.

00:05:17

Now, the tool itself that were going to do a lot of this in is called the HANA Application
Lifecycle Management tool.

15

00:05:24

This is a web-based tool that runs directly out of HANA.

00:05:28

And the idea was Of course, you can continue to use some of the ABAP-based lifecycle
management tools like Solution Manager.

00:05:36

If you have the ABAP environment, youre doing HANA development in conjunction with nonHANA development,

00:05:43

you know, youre doing ABAP development and HANA development mixed, you probably want
to continue to use Solution Manager.

00:05:48

But therere many use cases where you want to do HANA native development standalone.

00:05:53

And then you want a lightweight transport management and application lifecycle management
tool that does not require any external server or software to be installed.

00:06:02

So, thats really the beauty of the HANA Application Lifecycle Management tool.

00:06:07

This is completely self-contained within HANA and it allows you to do all the lifecycle
management you would need for any HANA native development.

00:06:16

It runs in a web browser so theres very little setup. To be able to get started, you launch the
web browser as well see here in a second.

00:06:24

And you can do all kinds of things, theres administration functionality to actually do the
transport, set up automated transports, things like that.

00:06:32

Then the developer, therere tools in here for you to be able to go in and start your initial
project, to run some wizards.

00:06:40

So when I even going to go to the HANA Studio first to start a project well going to come here
to the Application Lifecycle Management tool.

00:06:48

Now, the constraints of this tool is that theres no centralized management for extended system
landscapes.

00:06:55

You have to run the HANA Application Lifecycle Management on each HANA instance and you
have to set up the, really, the transport landscape, the routes in each of the systems.

00:07:06

Theres no transport synchronization for any non-SAP HANA content either.

00:07:11

So, the whole focus of this tool is only the content that you put in the SAP HANA repository.

00:07:16

And finally, theres no or very little integration with other SAP process tools.

00:07:22

Were just starting to get a little bit of integration in the latest support package, in SP8, between
the HANA Application Lifecycle Management tool and Solution Manager.

00:07:33

So, well continue to build that out a little bit but the idea is that if youre using the HANA
Application Lifecycle Management tool,

00:07:39

youre really looking at using it for HANA standalone development.

00:07:45

And finally, the part thats most concerning to developers is the Create Application Wizard.

00:07:52

So this is a very nice wizard that will do a lot things for you.

00:07:55

It will set up your initial schema, your local developer role, your Eclipse project, and the
xsaccess and app file that Rich was talking about in the previous unit.

00:08:08

So at this point, lets go into the system and lets start our project.

16

00:08:12

So, really what we have here is Ive brought up the HANA Application Lifecycle Management
tool.

00:08:18

And this home tab, the first one that opens to us is sort of like a little bit of a dashboard.

00:08:23

It shows you all of your recent transports and if you have any that have failed or anything like
that.

00:08:28

Now for developers, were really going to work in the PRODUCTS tab, primarily.

00:08:34

And while we were talking, it timed out, of course.

00:08:39

So, we just log back in quickly.

00:08:47

Here we are. Now we go to the PROUCTS tab.

00:08:50

And where we are going to be working when we first start is we are going to be working with
the packages.

00:08:55

And what we see here is the package hierarchy in the HANA repository.

00:09:00

But not any of the content itself so this is only showing us the packages.

00:09:05

And for instance, if we come here to workshop/exercises, where we are going to be doing all of
our work, you can see that we already have a group 00 package.

00:09:13

Thats there where Rich and Ive already done all the exercises. Well be showing you finished
demos from this package.

00:09:20

But what we also want is we want to create a second project so that we can demonstrate the
process as we go along.

00:09:26

Sort of like cooking show style where well bake it up to a certain part but then you dont want
to watch and wait while it cooks in the oven.

00:09:33

Well, well pull the finished, beautiful-looking finished product out and show it to you.

00:09:37

So dont be confused as we go back and forth between the g00 and the g01 packages.

00:09:45

But what were going to do here is we want to create a new package for group 01.

00:09:50

So in the past, we would have gone to the HANA Studio to create the packages. Now you can
do it from this web-based tool instead.

00:09:56

So Ill just say Create and I want to create a new package called g01.

00:10:00

Please do keep in mind that packages like many objects in SAP HANA are case-sensitive.

00:10:06

And that will particularly come into play later because your package structure also becomes
the URL path of your applications when you run them from a web browser.

00:10:15

And the most common mistake that people make is using upper case at this point and then
testing later and not using upper case.

00:10:24

So we go ahead and give it a description: Group 1, and we can leave the rest blank.

00:10:32

So now I have a new group, and inside this group I want to create a new project and generate
all the initial artifacts.

00:10:42

So I can come here and I can just say Create Application and I have some options here:

17

00:10:47

I do want authentication on my applications so I want at least basic or form-based

authentication.

00:10:52

I do want a new database schema, so I call this HANA_WORKSHOP_01.

00:11:01

I do want a developer role. Ill talk to you more about that in just a second because this is an
important part of what this tool is doing.

00:11:10

I do want to create a new project for Eclipse and I call this Exercises01.

00:11:18

And Ill create an initial index.html, and what this is doing: This is going to create the xsaccess
and xsapp file for us.

00:11:28

Its going to put it all in the repository right in this folder that Im creating. Its going to create the
initial database schema.

00:11:34

Its going to create an Eclipse project so we will be able to go back to the Studio and just check
all this content out and very quickly get started.

00:11:41

It will create a little html file just so we can test and make sure that everything weve done so
far works just right.

00:11:47

And the other thing that it is going to do it is going to create a local developer role.

00:11:52

So, its going to create a role here in sys-local not so that it can be transported

00:11:58

but so the developers as theyre working on this project will automatically have access to the
schema and all the objects in it.

00:12:04

So in order to get started working all you really have to do is grant this role to your developers

00:12:11

and theyll have everything they need to test any of these objects that they create inside the
schema

00:12:16

rather than having to grant a lot of individual objects as you create them.

00:12:21

So, Ill go ahead and hit Create, and itll takes just a second or two, and it was successful.

00:12:27

It shows me that it created an xsapp, it created a schema, hdbschema file, it created xsaccess,
it created my system-local role and it created my index.html, my project file.

00:12:42

So, thats all we really need to do in the admin tool right now, in the Application Lifecycle
Management tool.

00:12:49

When we go back over to the HANA Studio now, where Im going to do the rest of my work.

00:12:55

And youll see here in the repository browser, this shows us everything thats on the server.

00:13:01

And if I expand this, you dont see g00 yet, thats because this tool is showing me the previous,
the cache version. Ill just hit F5 to refresh.

00:13:10

And now I see g01, and all the content that that wizard just created is right here.

00:13:16

You know, I have a schema and xsaccess and, most importantly, Ive got a little .project file.

00:13:21

That means as soon as I want to start working on this project all I have to do is right mouse
click, say Check Out and Import Projects.

00:13:29

Its copying all those files down to my local PC and now Im adding that project to my Project
Explorer.

18

00:13:35

I go back over to the Project Explorer. Ive got my Exercises01 project and all my content is
checked out ready to do further development on.

00:13:45

Ive got my xsaccess file, its got some just basic authentication set, we have our schema
already created here for us.

00:13:56

And actually well already be able to go to the catalog as well and see that schema also.

00:14:03

So everything is basically ready to start development. In your exercises that youll do youll also
see how to grant yourself the initial role,

00:14:12

how to change the xsaccess file because maybe we want form-based authentication and
maybe we want to have some cache control, some of the advanced settings.

00:14:20

But right now, were really ready to start the rest of our development but maybe we just want to
test something here,

00:14:26

maybe we just want to go ahead and run this index.html. And what you see here is it opens
that web page in a browser window for us.

00:14:35

This is a newer feature of the HANA Studio. You no longer have to type in the URLs, we can
just test them directly from the tooling.

00:14:42

Ill get a little button that says Hello. When I click on it, it says Hello world. Not anything
spectacular

00:14:48

but its enough to tell us that the objects were generated correctly, that theyre accessible over
the web browser, that, you know, the basic authentication is set up right.

00:14:58

So, you know, just starting off, that Ive got a project that works and is ready for further
development.

00:15:03

Which well see in the subsequent units.

19

WEEK 1, UNIT 5
00:00:12

Welcome back to Unit 5, and in this unit we are going to talk about the Web-Based
Workbench.

00:00:19

So in SP6, we introduced two separate IDEs, one is the full version, and then one is the light
version.

00:00:28

Now in SP7, we merged these two IDEs together so that we had one IDE moving forward.

00:00:36

And, this is an alternative to using the Studio. It shares some of the basic features and
functionality of the Studio

00:00:47

but does not have all of the features of the Studio.

00:00:50

Some of the advantages of using the Web-Based Workbench over the Studio include having a
zero installation

00:00:59

so there is nothing to install. You simply access it via the browser and do all of your work within
the browser itself.

00:01:09

Another advantage is the fact that the version is always the same as the server that you are
running it from.

00:01:16

So there is no chance of mismatching the Studio version with the server.

00:01:22

And finally, the fact that you can run it on the browser allows you to run it on a mobile device.

00:01:29

So, say, for example, you are at the airport and you have to make a quick change to maybe a
role or something that's broken,

00:01:37

you of course can access it via a mobile device and make that quick change while you're
sitting at the airport.

00:01:46

So again, this is a completely browser-based IDE, lightweight, for creating and editing
development objects within HANA.

00:01:55

You are also able to do debugging for a server-side Java script.

00:02:01

We can access the editor via the direct URL sap/hana/xs/editor.

00:02:09

Within this editor we have full access to the HANA repository within the browser

00:02:16

where we can create, delete and rename packages and files within these packages.

00:02:23

The code editors support things like syntax coloring, code folding, client-side and server-side
syntax checking,

00:02:32

as well as with this approach there is no need to check out the files to your local project like
you do in the Studio.

00:02:40

It's direct editing. So, you open up the file, you edit the file and click Save,

00:02:45

and it's automatically committed to the server and the activation is done automatically for you.

00:02:52

Again I mention the debugging support because today we support the debugging of serverside Java scripts.

00:03:00

And in a future support package, we of course will allow for the debugging of procedures as
well SQL script procedures.

20

00:03:06

So we can set breakpoints within the editor and do evaluation of the variables within the
server-side Java script as well as the parameters.

00:03:18

We have full access to the catalog so we can browse the tables, views, procedures and
functions,

00:03:26

the run-time objects themselves that are generated by our repository.

00:03:31

We can access this via the sap/hana/xs/catalog direct URL.

00:03:40

For security, we are able to maintain and create users directly from the web IDE.

00:03:50

We are also allowed to assign roles to those users and we can access this via the direct URL
sap/hana/xs/security.

00:04:01

We also have the ability to view trace files from the web IDE.

00:04:06

Now, we are able to view trace files for the Index Server and the XS Engine trace files only.

00:04:15

We can access this via the /sap/hana/xs/trace direct URL.

00:04:23

So we can go to the demo here: So this is the landing page for the Web-Based Development
Workbench.

00:04:32

And you can see here, I have four separate areas I can access.

00:04:37

So I can go into the editor. And I was planning on that happening.

00:04:47

So I go ahead and relog in.

00:04:58

So, this is the editor, the web-based editor.

00:05:01

You can see here, I have a complete access to the HANA repository under the Content folder
here.

00:05:11

So, if we browse to the workshop package, and under exercises, and then under the g01
package,

00:05:21

we see the artifacts that Thomas created in the earlier unit. And you can see...

00:05:28

You can open up these files and edit those files directly.

00:05:35

If we go ahead and open up the index.html file here, again, basically the same editor that you
would see in the Studio

00:05:45

but you have direct access to this via the web. So, if I wanted to go ahead and change this,

00:05:50

I can say "Hello World!... instead of "Hello World!", I say "Hello openSAP!", and click Save,

00:05:58

and when I do that, it does an automatic commit and activation on the server side.

00:06:02

So, there's no... I don't have to do a Save and an activation like I do in the Studio. It happens
all for me automatically.

00:06:11

So if I go ahead and run this then simply by selecting it, and say Run.

00:06:22

And when I click Say Hello, it says Hello openSAP!

00:06:26

So again, you can see the direct editing effect here without having to do activation.

00:06:32

As soon as you save it, it's automatically activated and automatically live.

21

00:06:38

Another cool feature within the web IDE is the ability to debug.

00:06:46

So if I browse out to one of my services called multiply here it is.

00:06:56

So this is a very basic service that accepts two input parameters: num1, num2,

00:07:03

multiplies them and gives the result out to the response.

00:07:07

So I can go ahead and set breakpoints within the editor here. So I set a breakpoint at the line 3
here.

00:07:14

And then I can say... I can simply go ahead and run this.

00:07:20

When I run this, it automatically opens the browser, and I know that this contains some URL
parameters

00:07:29

that is required, for example, it's expecting a command. So in this case it's multiply.

00:07:36

And then it's expecting input parameters num1 and num2. And I'll pass 5 to both of those.

00:07:42

And right now it's sitting and waiting for me to go back to the editor and debug it.

00:07:47

So you can see, when I switch back to the editor here, processing has stopped at line 3.

00:07:53

And if I go ahead and Step, you can see over here on the right that num1 and num2 both
contain 5.

00:08:05

And Ill continue to debug, and I look here, an answer it now has 25.

00:08:12

And so I, and this is how I'm able to debug on the fly via the web-based IDE.

00:08:21

Continuing on, I also have the ability to access the catalog directly.

00:08:26

So I can click on Catalog and browse all the artifacts within the schemas within the catalog.

00:08:32

So you can see all my schemas are listed here. And let's just browse to
HANA_WORKSHOP_01.

00:08:38

And you can see I have sub- folders for all of the various artifacts:

00:08:45

Views, Functions, Procedures, Sequences, Tables, Triggers, and Views.

00:08:50

I don't think we have anything created in here quite yet, so we won't see anything in there

00:08:54

but basically it acts the same way as View in the catalog in the Studio would.

00:08:59

All of your functions would be in the Functions folder, so on and so forth.

00:09:07

I believe that's it for this unit. Thank you very much.

00:09:12

In the next unit, we'll see many of the same features but in the HANA Studio

00:09:16

so you can compare and contrast how they work, particularly some of the newer advanced
features of the HANA Studio.

22

WEEK 1, UNIT 6
00:00:12

Welcome to Week 1, Unit 6, Tooling SAP HANA Studio Basics.

00:00:18

So weve already seen a little bit of the HANA Studio as we did some of the earlier units

00:00:24

and of course, a lot of this should be a review for you. Were going to cover just some of the
basic interactions in the HANA Studio.

00:00:30

More importantly in this unit, I want to show you some of the improvements weve made to the
basic functionality in the HANA Studio.

00:00:40

So, first of all, just backing up a bit, what is the HANA Studio. Hopefully was everyone taking
this course and you already have some of experience doing some work in HANA

00:00:50

and you are already familiar with the HANA Studio. But if not, this is the main development
environment for working with and administrating HANA.

00:00:59

Its based upon Eclipse. And the whole idea is to provide really an integrated environment to
do all these different kinds of activities:

00:01:08

To have tools to be able to, as we saw in the previous exercise, browse the catalog as well as
work with content in source code repository,

00:01:18

and then go beyond that and take advantage of some Eclipse-specific features like projects,

00:01:24

and we have this mechanism to check out files and bring them down to the local PC.

00:01:29

And part of that is so that we can utilize standard Eclipse editors and other tools on these files

00:01:36

even though that they are stored automatically in the HANA repository.

00:01:40

So, really this should cover the complete lifecycle of doing your development, doing your
testing, doing your debugging,

00:01:47

because we have both server-side Java script and SQL script debugging inside the HANA
Studio, offer supportability

00:01:54

and many of the lifecycle management capabilities as well.

00:01:58

And increasingly some of those lifecycle management capabilities actually open in a web
browser inside of the Studio.

00:02:04

As youre beginning to see how we are doing some of the tooling and administration like the
HANA Application Lifecycle Management with the XS Admin Tool in a web browser.

00:02:13

But that doesnt mean that we cant run those inside of the Studio as well.

00:02:19

In the end what we want the Studio to have is a very Eclipse look-and-feel, it is based upon the
standard Eclipse.

00:02:26

So if youre already familiar with doing development in Eclipse, you should feel right at home in
the HANA Studio.

00:02:32

We have dedicated perspectives and views.

00:02:37

So, perspectives are an Eclipse concept to basically switch the layout of the IDE. So switch up
which tools and which reviews are visible

00:02:48

and where they are located on the screen. Now, primarily, were going to be working in the
SAP HANA Development perspective.

23

00:02:54

Really other than debugging, the debug perspective, well do all of our work in the
development perspective.

00:03:02

Now, when youre in the development perspective, theres three primary views that you interact
with. One is the Project Explorer.

00:03:09

This is the standard Eclipse Project Explorer. It shows you all of your projects, both the HANA
ones and the non-HANA ones.

00:03:17

Thats also one of the benefits of using Eclipse-based development environment is that the
HANA capabilities,

00:03:25

the editors and perspectives are just add-ins to Eclipse. So inside one Eclipse installation on
one HANA Studio installation we can also install other tools.

00:03:34

You can install ABAP-based development tools. SAP UI5, Java-based development.

00:03:40

And in this case, in the Project Explorer I might have an ABAP project or a Java project right
here alongside by my HANA projects.

00:03:49

Next we have the other two views in this perspective and both these are HANA-specific.

00:03:58

First one is the Repositories tab. The Repositories tab shows you your source code repository.

00:04:05

It shows you all the development artifacts as they exist on the server. Thats how we can check
out content, bring it from the server and copy it down to our local PC.

00:04:15

So then we can then edit it with local Eclipse projects.

00:04:20

Finally, there is the Systems tab. Now this is sort of the legacy tab if you will.

00:04:26

It was the one that was originally the main view inside of the HANA Studio for both
administration and modeling perspectives.

00:04:35

It shows you content folders although not all the development artifacts that the repository
shows.

00:04:41

Its primarily designed to work with the modeling tools. And it shows you the catalog.

00:04:48

It also has some administration capabilities like the ability to edit users.

00:04:53

What weve done over time is weve taken most of the functionality of the Systems tab and
weve moved it into either the Repositories tab or the Project Explorer.

00:05:02

I will show you some of that in this unit and in the next unit.

00:05:06

Eventually, we would like to phase out the Systems tab all together once all the functionality
that it contains is migrated over to the other two tabs.

00:05:16

We also have workspaces and projects. So this is where the terminology maybe gets a little
confusing on workspaces in particular because weve kind of overloaded this term.

00:05:27

Because in Eclipse you have a workspace. So, a single instance of Eclipse all the projects are
stored in a workspace.

00:05:37

And thats just basically the folder on your PC where all the Eclipse settings are stored and
generally where all your projects are stored inside there as well.

00:05:46

On the other hand, we have something that we call workspaces in the HANA repository, so
those are HANA repository workspaces.

24

00:05:54

In this case you can have multiple of these because you have one repository workspace for
every HANA system that you connect to.

00:06:03

And what that really is its a folder on your PC that represents each HANA system.

00:06:09

And that way you could technically have checked out objects the same project from two
different HANA systems, have copies of both of those locally.

00:06:19

So we have to have some structure to keep those separate. The repository workspace also
keeps track of what system those objects are connected to.

00:06:29

So that, when you save an object in a project thats connected to that repository workspace it
knows which HANA server to automatically send it back to

00:06:36

or which user to utilize when it saves that back to the server.

00:06:41

And then finally projects, those are standard Eclipse projects, we have a special HANA project
type, an XS project, we also have the River project type.

00:06:50

You might also work with SAPUI5 project types. All which are stored in the HANA repository
but to the front-end, to the Eclipse theyre just standard Eclipse projects.

00:07:02

So, in the end in the Project Explorer, as I said here, we have the ability to work with projects,
to share projects.

00:07:09

But this is where we do most of our development. And thats where we actually changing the
objects.

00:07:13

This is our navigation mechanism for moving between the development objects that were
working with at that time.

00:07:21

One of the new enhancements that we have is in the project creation wizard.

00:07:25

We were trying to take some of the functionality that is available in the HANA Application
Lifecycle Management tool or in the web IDE

00:07:35

and bring it back into the Studio as well. And one of the main areas of feedback weve got from
customers was

00:07:40

that there were too many steps involved in creating a project, sharing a project and, you know,
in standing everything up.

00:07:46

So now, we have automatic sharing of project in the HANA repository.

00:07:51

So, youve already seen the process of if I go to HALM, the HANA Application Lifecycle
Management tool,

00:07:59

and I create my project in advance and its stored in the HANA repository and I want to check it
out.

00:08:03

What if Im doing the opposite, what if Im starting with the project. This works fine as well.

00:08:10

So I come here. And Im just going to say File, New, Project and Im going to choose an SAP
HANA project and Im going to choose this XS Project type.

00:08:20

Thats what we use most of the time unless, like I said, youre doing either a River project or an
SAPUI5.

00:08:26

Well see the SAPUI5 projects and utilize those later once we start creating user interfaces.

25

00:08:33

But for now Im going to put everything into my XS Project. So I just come here and Ill give it a
new project name.

00:08:40

Lets call this one, lets just call this one Demo, and by default this new option is selected here:
Share project in SAP HANA repository.

00:08:51

So now, when I go to the next phase, it wants to know which system do I want to connect this
up to. So I only have the one system.

00:08:59

Thats pretty easy. I could also go ahead and add a new system entry here if I wanted to.

00:09:06

And a new repository workspace This is really just telling me where are my local file system,
I want the local files copied into.

00:09:14

And then what system or what user I want to connect up with.

00:09:19

In this case Im just going to use the one that I already have created. Im going to say Demo,
and Im going to say Add Project as a Folder of the Subpackage.

00:09:28

So I can browse here into the repository and tell the system where I want to create this project.
And Ill put it in workshop and Im going to put it in exercises.

00:09:37

And this is just for the purpose of demo so I just stick it in here, right under exercises.

00:09:42

So its checking, make sure that Im authorized to do that and youll see that it is going to it put
into workshop.exercises

00:09:48

and its going to create a new package, named Demo within exercises.

00:09:52

And you also see that it is going to basically copy this, the content, itll place the content into
my repository workspace

00:10:01

and itll create the same folder structure here on my local PC.

00:10:05

I go ahead and say Finish. And now I have both, a new project and I have that project shared
to the repository.

00:10:18

Now, if I were to come back over here and then I would go ahead and hit F5.

00:10:24

You actually see that this Demo is here and, now, theres not much in it yet, we havent really
done anything to it.

00:10:32

Now, this is where we have some other new enhancements as well.

00:10:35

We want to make it easier when youre creating projects from within the Studio to also create
some of the other artifacts.

00:10:42

So Ill say File, New, Other, and I say SAP HANA and I go ahead and create an xsaccess file.

00:10:53

But new here in SP8 are the ability to have templates.

00:10:59

So, rather than just having an empty file Im going to choose the basic template. Ill say
Finished and then youll see that it has inserted a lot of the options for me.

00:11:08

It saves me time typing, it also saves me time having to go to the documentation.

00:11:12

Maybe youll look up what some of these options are, you know, what the syntax is for some of
these options.

00:11:18

Now I could maybe just tweak the options the way I wanted them but the most commonly ones
used are here.

26

00:11:24

Now, what you are beginning to see is this transition. We showed you how you could use the
HALM tool,

00:11:29

and it would create the project and create the schema and a lot of objects for you.

00:11:34

Or you can come here to the Studio and you can use these wizards.

00:11:39

For now, the wizards are fairly basic as you saw there was just one to choose from here on
xsaccess.

00:11:45

If I came here and maybe chose to create an XS OData service, then you would see its got
one basic template as well.

00:11:53

What we want to do in the near future is we want to add more templates, so for different
scenarios.

00:11:58

Maybe well have a basic OData service template and then have an advanced, that had two
objects and associations.

00:12:05

We also want to make it so that you can create your own templates.

00:12:09

Therere stored on the server but then are available inside the tooling.

00:12:12

So ideally, we want to bring together a lot of the functionality that you have in the HANA
Application Lifecycle Management tool

00:12:19

all to create multiple objects at once, have template content created in them, but bring that into
the Studio

00:12:25

and even make it so that you can create your own company-specific templates as well.

00:12:32

So returning to the slides, we see here in this File, New wizards. I showed you that you can
use this with XSACCESS and with XSODATA.

00:12:41

We also have basic templates for server-side Java script, new HTTP destinations, SQLCC,
thats used for anonymous setting up anonymous services, and the new JOB functionality.

00:12:53

Many of these items well use and well introduce these concepts like outbound HTTP
destinations and JOBs later in subsequent weeks.

00:13:00

And then youll also see the wizards at play as well.

00:13:05

And with that, that really brings us to the end of the basic functionality of using the HANA
Studio

00:13:12

as well as some of the new enhancements that we have made to the basic functionality.

00:13:16

In the next unit I want to show you some of the advanced capabilities in the HANA Studio as
well.

27

WEEK 1, UNIT 7
00:00:12

Welcome to Week 1, Unit 7, Tooling SAP HANA Studio Advanced Features.

00:00:19

So, building on the previous unit, we want to continue looking at the features of the HANA
Studio

00:00:25

and in this unit in particular I want to introduce you to some of the more advanced features the
of HANA Studio,

00:00:31

and in particular ones that are... have been newly introduced primarily in SP7 or SP8.

00:00:41

So, first of all, if you've used the HANA Studio in the past, particularly in the SP5 and SP6
timeframe,

00:00:49

then you would remember that we used to have that tool called REGI.

00:00:53

And what you had to do is you had to install both, the HANA Studio and the HANA client on
your PC

00:00:59

and then you had to go into the HANA Studio and you had to configure the location of the
repository interface, the REGI file.

00:01:08

And that was because the HANA Studio itself didn't have the implementation that allowed it

00:01:13

to communicate with the HANA server and check out files. All this was actually done via an
external executable.

00:01:21

We had to call over out of the Studio to this other executable.

00:01:26

Now, that had some disadvantages because it complicated the installation.

00:01:30

And what's probably one of the most common problems that people had was they mismatched
the version of REGI with the Studio:

00:01:38

They were using 32-bit of the client and 64-bit of the Studio or any number of problems.

00:01:44

The other thing that this caused is, because of the way that we had to call out to this external
executable,

00:01:51

this actually created some performance problems because we couldn't do batch operations,

00:01:56

we had to call one command at a time, and when you were checking out a large number of
files,

00:02:02

this often led to some performance problems, particularly when there was lot of network
latency.

00:02:10

We've done some projects, we've done some, you know, workshops in remote corners of the
world

00:02:16

where when you were checking out hundreds of files it would take a little while

00:02:19

because it was having to wait for each previous file to finish before it moved on to the next one.

00:02:25

Now, what we've done in SP7 is we've done away with the need for REGI and for the HANA
client,

00:02:32

and we've built a repository interface directly into the HANA Studio.

00:02:37

So, first thing it does, simplifies the installation process. There's one tool, HANA Studio,

28

00:02:42

you're often running and you no longer have to have the HANA client installed on your
machine as well.

00:02:48

It also really helped with the performance problems. That was a welcome relief to many of us.

00:02:57

And the other thing that this did is that we have much better dependency checking

00:03:02

because before, when REGI would send a single file at a time to the server,

00:03:06

the order that it sent them to the server would affect the order that they were activated.

00:03:10

You know, if the server were trying to activate both a table and then the procedure that use
that table,

00:03:16

REGI unfortunately, you know, might... the Studio might send out one file at a time and it might
actually send the procedure first,

00:03:22

and then of course the activation would fail because the table didn't exist yet.

00:03:26

And now, because we send all the objects up in one batch and then the activation occurs on
the server,

00:03:33

the server can analyze all the objects and all the dependencies between those objects

00:03:36

and we will get much better quality activation on the first time, so we shouldn't have any more
of those failed activations

00:03:43

just because, you know, not all the objects were processed in the correct order.

00:03:50

Now, some of the other advanced features that we have: In the repository browser itself we've
added several new capabilities.

00:03:59

So, first of all, now we can edit the package itself, the definitions of the package

00:04:06

and create new packages directly from the repository browser.

00:04:10

It used to be we had to go out to the HANA Application Lifecycle Management tool

00:04:15

or we had to go over to the Systems view to be able to do this.

00:04:19

This is part of that, what I talked about in a previous unit, taking all of the functionality of
System view

00:04:24

and trying to bring it into either the repository browser or the Project Explorer.

00:04:31

In a future, we'd even like to make it so that you can directly edit objects in the repository
browser

00:04:37

without having to do the checkout of a project and do the activation,

00:04:42

so more... an experience closer to what we saw with the Web IDE.

00:04:48

Another option is Remove From Client. So if you've done a checkout of the objects to your
local PC

00:04:54

and you want to clean them up but you don't actually want to delete them from the server,

00:04:58

that's what this Remove From Client option allows you to do.

00:05:01

The Regenerate option so, Regenerate is nice for when something has gone wrong.

00:05:06

Maybe you've imported some content into your system and there was a problem during the

29

import process,
00:05:11

that something didn't activate correctly, and you want to force the reactivation.

00:05:16

In the past, what you had to do is you had to re-checkout that project so you had a local copy,

00:05:20

you had to edit the file, maybe just add a space to the end of the file, and only then could you
activate it.

00:05:25

Because if you didn't make any changes to the file and you just told it to activate, it'd say
there's nothing to activate.

00:05:31

Well, the Regenerate basically ignores whatever the status of the object is and enforces
reactivation

00:05:38

and you can do this directly from the repository browser without having to check out the files or
edit them locally.

00:05:45

And then finally, we have much better processing of the deletion, and deletion of multiple
folders, and folders that have content.

00:05:54

And in the past, we had this limitation that you could only delete empty folders.

00:05:59

So it meant you had to go a folder at a time, delete all of the content, and only then could you
move up to the higher level.

00:06:05

Now, you have full recursive deletion: I can go up to a higher level package, I can delete it,

00:06:10

I get a confirmation, you know: Are you sure you want to do this? And then it will delete all
content in all subfolders as well.

00:06:17

Helps for mass clean-up of parts of the repository browser.

00:06:22

We also have enhancements to the Project Explorer, and one of the most important ones is

00:06:28

that now we have the Catalog folder in the Project Explorer.

00:06:32

And what this allows us to do is see all of our schemas and all of our tables and all of our
catalog run-time objects

00:06:38

without having to switch over to the SAP HANA Systems view.

00:06:42

So, once again, this idea that we want to get away from having three tabs and having the
separate HANA Systems view

00:06:49

and, instead, embed that functionality into either the repository browser or the Project Explorer
itself.

00:06:58

The other nice thing about this is, you know, the project already knows which HANA system it's
connected to,

00:07:03

so you are automatically going to see the catalog folders for just the system that is shared with
this particular project.

00:07:11

In addition, we have some additional features built into the Team menu itself,

00:07:17

some of which we'll talk about here in a second just when we get to some of the other new
features.

00:07:23

This is a great new feature. It seems like such a simple thing, this Run As option.

30

00:07:27

And I already used it once earlier in one of the previous units but to me this is so major

00:07:33

because, up to this point when we introduced this concept, we typed all the URLs.

00:07:38

If you wanted to test something, it opened the web browser, we had to type the URLs in.

00:07:42

But now we have this Run capability. So if I come back to the Studio here, you can see I've got
a project checked out,

00:07:51

I've got the epmNext demo project. You want to test some of these things that are in here. You
want to test some of the HTML.

00:07:58

Instead of looking up the URL, building the whole URL path looking off the server and the ports
and all that,

00:08:04

I can just do Run As, HTML. It is going to open in a web browser. Of course I still have to
authenticate...

00:08:17

Then my application runs. And it just saves me the time and trouble of typing in the URL.

00:08:24

Might seem like a lazy sort of thing but it really cuts down a lot of errors.

00:08:30

And this works not just for HTML pages, but works for services as well.

00:08:37

I do the Run As on a row data, xsodata. If I want just the service, I do a Run As on xsjs.

00:08:50

It, well, not just the xsjs. This particular one would require some input parameters.

00:08:54

but you'll see us using this all throughout the rest of this workshop,

00:08:58

and all the exercises are built to do the testing from this Run As as well.

00:09:03

In future, well, we would like to further improve the Run As, add it for more development
artifacts,

00:09:09

and build in some additional capabilities. In a near future, we'd like to build in like a whole rest,

00:09:15

a test framework basically for the Run As or Debug options as well.

00:09:20

So, we'll continue to really build this functionality out and make it a full testing environment.

00:09:28

Now, returning to the slides, some of the other features:

00:09:32

Now, on activation, when you have multiple objects and you say Activate, a dialog will pop up.

00:09:39

And it will show you all of your inactive objects. This is one of the common mistakes that
people made as well:

00:09:44

They hit Activate and they didn't select all the objects in their project, and then something didn't
work

00:09:48

like, you know, the service call failed from the user interface; well it turns out they hadn't
activated that object.

00:09:54

Well, this just helps you to see which of your objects are inactive and cuts down on that
problem

00:09:59

because you can more easily say Select All and activate all the objects in your project at once.

00:10:05

Another new major feature is the Change Manager. So, this was an often requested feature,

00:10:12

particularly from development teams that were used to the ABAP development environment.

31

00:10:16

And what this allows us to do is automatically record all of your changes.

00:10:21

Because in... without the Change Manager, before we had this, what was a common problem
was

00:10:29

you would go and maybe have two developers, both working on objects in the same project.

00:10:35

And, Rich is working on one object. He added the view.

00:10:39

And I'm working on another part of the project and I added a service.

00:10:43

And I finished my work. It's good, it's ready to move to the next system, it's ready to move to
production.

00:10:49

Rich is still working on his. I don't know about Rich's object and I export the delivery unit.

00:10:55

When I export the delivery unit, it takes the current state of all the objects with it.

00:11:00

So it took not only my new changes, which were ready to go to production, but it took Rich's
changes which he was still working on.

00:11:07

And this created a problem of accidentally taking things to production sooner than what we
would like.

00:11:12

Now you have this option to turn on the Change Manager. Now, this is not on by default.

00:11:18

This is something your system admins have to go in and turn on for you.

00:11:21

But when you do have this turned on, even for objects in the same package, in the same
delivery unit,

00:11:27

every time you change an object it has to be assigned to a Change.

00:11:31

So, I would change one object and Rich would change his object, and they would go into two
separate Changes.

00:11:38

And I'm ready to transport my changes, I first have to release my Change.

00:11:43

So, even if we were making changes to the same objects in the same Change, I would know
about his objects,

00:11:48

and he would have to approve his change, so say his object are really ready to go.

00:11:52

So, everybody has to release their changes, and then you know that everything is ready to
move.

00:11:57

But it also allows you to move only those objects that are assigned to a Change.

00:12:00

So in the first scenario, where he is working on one object in this delivery unit,

00:12:05

I'm working on a completely other one, we've assigned them to two different Changes.

00:12:10

When I release my Change, only the objects assigned to that Change are transported,

00:12:14

not the complete delivery unit but only the objects assigned to a Change.

00:12:18

So, it allows much more granular control over the application lifecycle management,

00:12:24

in particular the transporting of objects in systems where you have multiple developers working
in parallel on the same projects.

00:12:32

So, I think for those of you that are used to the ABAP development environment, the CTS

32

change management,
00:12:37

it's going to feel very similar because we really designed it with many of the same concepts in
mind, you know,

00:12:43

the contributors, the way it releases all very similar to that environment.

00:12:50

So, another feature that helps a great deal with multiple users working on the same object is
server-side version management.

00:13:01

So up until SP8, we actually had always tracked the version management on the server.

00:13:09

Every time that you commit a file to the server, it's stored in a version's table. Every time you
do the Activate, that's stored.

00:13:18

But up until SP8, we had no visibility to those versions.

00:13:21

There was just nothing built in the tooling that gave you access to those versions.

00:13:27

And, so we forgot all that history in there but now we finally have a way to access it.

00:13:32

And I want to go into the system and show you some demos of this.

00:13:36

What I am going to do is I want to take a couple of the objects from our examples.

00:13:41

Actually, I want to start off with something really simple here. I'll just start with my HelloWorld
and this little index.html.

00:13:50

The first thing I can do is I can right-mouse clicking on an object, and I can say Team,

00:13:57

and then I can say Show In, History, or you can just go to the History tab and you can say Link
with Editor,

00:14:04

and then it's automatically going to show you the history for whatever objects you have.

00:14:09

Now, I just created this object not that long ago, so it doesn't have any versions yet.

00:14:14

But let's go ahead and let's make a little change to it. Instead of SAP UI5 in 20 Seconds, let's
call this openSAP Example.

00:14:25

And you'll see, I'll save it, and right away here I even see my inactive versions.

00:14:33

And I have the ability... one of the nice things that I can do here is I can say Compare with the
active version.

00:14:39

So, we have an easy way to always compare our inactive version with our active version, you
see the split screen editor

00:14:46

and using a standard Eclipse of version comparing editor, we have the ability to see the
differences between these two files.

00:14:54

I can also... no. I'll just come here and I'll activate this.

00:15:00

So, now I have the new active version but I still have access to the old version.

00:15:05

I could come here, and I can simply open and view the old version. So I can view both files.

00:15:10

I can cut and paste between the two. I can, once again, do the version management. So I can
say Compare with...

00:15:19

I can select 2 and say Compare with, Each Other. So I can arbitrarily compare any two

33

different versions.
00:15:26

I also have the ability to come back here and Check Out and Rebase to Active.

00:15:31

So I can take any previous version, just make it the current active version and clean up any
intermediate versions.

00:15:41

So, lots of version management capabilities, once again, built in the server. So, works across
multiple users.

00:15:46

You could see which user made the change. So, we have a version manager or we repair,
restore from previous versions.

00:15:53

But this even works on non-source code based objects. This is the part that I thought was
pretty cool.

00:15:59

If I come here to say one of the graphical modelling things. Let's just come here to this attribute
view.

00:16:05

And I'm going to make a very simple change here. I'm just going to change the...

00:16:09

Maybe I'll change the description here on the view itself: openSAP Demo.

00:16:15

That's fine. Then save that. And lets see...

00:16:22

Maybe Ill come in here and I'll also change, I don't know, one of my descriptions on one of my
labels.

00:16:30

So, CATEGORY1. Well make it really simple here. OK.

00:16:37

I'll save and I will activate.

00:16:45

And I'll look at my History...

00:16:55

History. You can see that I've got two versions here.

00:16:58

You go ahead and select them both, and even for this tool that's completely graphical, it's got
property boxes

00:17:04

and I made my changes there, and I say Compare with, Each Other and I even get comparison
here.

00:17:10

Now this uses a special comparison tool to actually show you, you know, what changed in a
hierarchy.

00:17:18

And, for instance, we see that the label changed on this particular column. We can see the
before and after values.

00:17:23

Or I can see that the basic description changed.

00:17:28

So, when I'm working with the raw XML that sits behind this attribute view, it really does break
it down,

00:17:34

show you the changes logically. So I think these are some great enhancements for the
usability

00:17:41

of the Studio tools in general, and particularly in multi-developer environments.

00:17:49

So, just the screenshots that show you the same things that I showed you in the live demo.

00:17:56

In addition, we were making some improvements to the editors as well.

34

00:18:00

So, in the past, we used just a basic source code editor, just a basic, well, overblown note pad

00:18:07

for editing many of the development artifacts. But now we are beginning to build in some
semantics in there.

00:18:14

So, if we look at the XSODATA and the HDBDD editors, we have syntax highlighting now,

00:18:21

the code coloring for the particular syntax. And we're beginning to add some code
completions.

00:18:28

So, what you're seeing is just basic keyword code completion for both these in SP8,

00:18:33

and in the near future, hopefully SP9, we have full syntactical code completion in these editors
as well.

00:18:40

Where, you know, you really go back as you start to type a table name and you do completion
on the tables and your schemas and things like that.

00:18:46

So, we've laid the foundation to really make these editors very powerful moving forward.

00:18:52

And then, finally, another feature that helps in large-scale development is Where-Used.

00:19:00

So, a lot of Where-Used find functionality in the HANA Studio itself comes from Eclipse

00:19:04

and will only search files on the local file system. So, that works fine if all your content were
checked out.

00:19:11

But more often you want to scan everything that's on the server.

00:19:16

So, we've added in SP8 a new Where-Used functionality that allows you to search, for
instance,

00:19:23

in this screenshot, I chose an xsprivileges file and I said Where-Used, and it goes back into the
repository

00:19:28

and really does an intelligent, semantical check to say, well,

00:19:32

that xsprivileges is used in these xsaccess files and in these roles.

00:19:37

So, it allows us to see the dependencies between objects. Particularly if you were changing the
definition of that privilege,

00:19:44

you want to know everywhere that it is consumed or every role that this is part of, and this tool
allows you to do that.

00:19:50

And of course it searches on the server, so as I said, you know, and we have the option to
search both, active versions or inactive versions.

00:19:59

So, maybe I'm searching for changes as I'm making them or I only want to search the active
versions.

00:20:05

So, that really brings us to the end of Week 1, there's a lot of high-level information, a lot of
review and a lot of looking at the tooling.

00:20:14

The exercises that are associated with Week 1 are really just to get you started creating your
project,

00:20:21

and a few things to make you comfortable with the tooling itself.

00:20:27

The other thing that I want to point out: If you go ahead and do the exercises for Week 1, you'll
use a lot of the wizards.

35

00:20:33

But I personally believe wizards are great but you should know how to do everything that the
wizards are doing.

00:20:39

So you should also look at the appendix at the end of the exercise document.

00:20:45

That shows you how to do all the things that the wizards do, but to do them manually.

00:20:50

So, how to create the schema file and the role and all this sort of things that the HALM tool
does for you,

00:20:57

but how to create them all manually. So, I'd encourage you to look at both of those parts.

00:21:03

As I said, that brings us to the conclusion of Week 1, join us again next week

00:21:08

where we begin to look at the database access level of the development process, where we
will create tables, schemas, views.

00:21:18

And, in particular, we'll look at the modelling and advanced modelling view capabilities of SAP
HANA.

36

www.sap.com

2014 SAP SE or an SAP affiliate company. All rights reserved.

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.
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. Please see
http://www.sap.com/corporate-en/legal/copyright/index.epx#trademark for
additional trademark information and notices. 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 SE or its affiliated companies shall not be liable for errors or
omissions with respect to the materials. The only warranties for SAP SE 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.
In particular, SAP SE or its affiliated companies have no obligation to pursue
any course of business outlined in this document or any related presentation,
or to develop or release any functionality mentioned therein. This document,
or any related presentation, and SAP SEs or its affiliated companies
strategy and possible future developments, products, and/or platform
directions and functionality are all subject to change and may be changed by
SAP SE or its affiliated companies at any time for any reason without notice.
The information in this document is not a commitment, promise, or legal
obligation to deliver any material, code, or functionality. All forward-looking
statements are subject to various risks and uncertainties that could cause
actual results to differ materially from expectations. Readers are cautioned
not to place undue reliance on these forward-looking statements, which
speak only as of their dates, and they should not be relied upon in making
purchasing decisions.