Showing posts with label SAPHANA. Show all posts
Showing posts with label SAPHANA. Show all posts

Monday, November 23, 2015

SAP HANA en la luna (con Lua)

Este post fué posteado originalmente en SAP HANA on the moon (with Lua).


Lua es un lenguaje de programación ligero diseñado como un lenguaje script con semántica extensible como primera regla. Lua es multi plataforma puesto que está escrito en ANSI C, y tiene una API de C relativamente simple.

Si están preguntándo acerca del título…bueno…Lua significa Luna en Portugués -;)


Lua es bastante potente pero sencillo de aprender y usar. Si ya saben Python o Ruby, no tendrán muchos problemas…

Antes de continuar…quiero compartir una pequeña broma…que no es especificamente única para Lua…pero aún así es graciosa -;)


Así que…ninguna demostración estaría completa si la enlazaramos con SAP HANA, so? Así que…vamos a hacerlo -;)

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que ahora podemos pasar a la parte de Lua…

Antes de continuar…debo de recomendar que instalen un par de cosas…si usan Linux…instalen esto…

sudo apt-get install lua5.2

Y luego sigan las instrucciones para instalar LuaRocks un manejador de paquetes para Lua…

Instalen los siguientes paquetes…

sudo luarocks install luasec
sudo luarocks install luajson
sudo luarocks install luasocket

Para programar en Lua, pueden utilizar cualquier editor que les guste…copien y peguen el siguiente código…

Lua_HANA.lua
http = require("socket.http")
mime = require("mime")
ltn12 = require("ltn12")
json = require("json")

h = {Authorization = "Basic " .. (mime.b64("SYSTEM:YourPassword")), 

     ["Content-Type"] = "application/json", ["content-length"] = jsonsize }

local resp ={}

ok, code, headers = http.request{url = "http://YourServer:8000/Flights/flights.xsodata/FLIGHTS?$format=json", 
     redirect = true, method = "GET", headers = h, source = source, 
                                 sink = ltn12.sink.table(resp)}

local dec = json.decode(resp[1])
local d = dec["d"]["results"]
for i = 1, #d do
 io.write(d[i]["CARRNAME"]," : ",d[i]["PRICE"], "\n")
end
print("")


Hacer esta integración con Lua fué rápido y sencillo…Lua es un lenguaje muy interesánte con algunas características muy buenas que no se pueden encontrar en otros lenguajes...

Saludos,

Blag.
Development Culture.

Monday, November 16, 2015

SAP HANA en las garras de Falcon

Falcon es un lenguaje de programación multi-paradígma y open source. Soporta programación procedural, orientad a objetos, basada en prototipos, funcional, tabular y de intercambio de mensajes. Apareció por primera vez hace unos 12 años atrás…así que no es un lenguaje nuevo e inmaduro. Era el lenguaje script for defecto del ya desaparecido sistema operativo Auroraux.


Falcon es bastante impresionante y tiene algunas características que otros lenguajes de programación matarían por tener -:)

Así que…ninguna demostración estaría completa si la enlazaramos con SAP HANA, so? Así que…vamos a hacerlo -;)

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que ahora podemos pasar a la parte de Erlang…

Falcon debería estar incluído en cualquier distribución de Linux…y estoy seguro de que ni siquiera se han dado cuenta -;)

En fín…también pueden instalarlo desde Falcon Releases...

Ahora…como aún soy un novato en Falcon…no estoy seguro si de verdad necesitamos esto…pero para estar seguros…instalamos esto…

apt-get install falconpl-curl

Son las libreías de Curl para Falcon…

Agarra tu editor favorito y copia y pega el siguiente código…

falcon_hana.fal
import from curl
import from json
h = curl.Handle("http://YourServer:8000/Flights/flights.xsodata/FLIGHTS?$format=json")
auth = "Authorization:Basic " + Base64.encode("SYSTEM:YourPassword")
headers = [auth]
h.setOption(curl.OPT.HTTPHEADER,headers)
h.setOption(curl.OPT.SSL_VERIFYPEER,false)
data = h.setOutString().exec().getData()

try
   raw = json.JSONdecode( data )
catch
   printl( "Can't decode the string" )
end

d = raw["d"]

results = d["results"]

for Index in [0:results.len()]
 print(results[Index]["CARRNAME"])
 print(" : ")
 printl(results[Index]["PRICE"])
end

Para ejecutarlo…simplemente abre una sesión en el terminal, anda a la carpeta donde tienes tu código y escribe...

Falcon falcon_hana.fal 



Debo admitir que esto no fué muy sencillo en un inicio…la documentación de Falcon no habla sobre curl…así que tuve que revisar el código en GitHub…hacer muchas pruebas…hasta que finalmente pude hacer que funcione…la parte de json por otro lado fué extremadamente sencilla -:D

Saludos,

Blag.
Development Culture.

Monday, November 09, 2015

Volviéndonos funcionales con SAP HANA y Erlang

Este post fué posteado originalmente en Getting functional with SAP HANA and Erlang.


Erlang es un lenguaje y sistema de ejecución concurrente de propósito general con recolección de variables. Y también es funcional, con evaluación impaciente, asignamiento único y tipeado dinámico. Me olvidé de mencionar que también es distribuído, concurrente y toleránte a fallos?.


Una descripción bastante grande, no? Bueno…Erlang ha estado presente desde hace más o menos los últimos 30 años…


Así que…ninguna demostración estaría completa si la enlazaramos con SAP HANA, so? Así que…vamos a hacerlo -;)

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que ahora podemos pasar a la parte de Erlang…

Erlang, a diferencia de muchos otros lenguajes, no tiene un manejador de paquetes, así que solamente debemos descargar el paquete que necesitamos, compilarlo y utilizarlo -;)

Para programar en Erlang uso uno de los más impresionántes editores que he encontrado hasta ahora…Geany. Viene practimente pre configurado para manejar muchos lenguajes de programación, así que debería dejarte listo para utilizar Erlang.

Necesitamos descargar mochijson2.erl y guardarlo en la carpeta de nuestro proyecto, luego simplemente debemos compilarlo escribiendo

erlc mochijson2.erl

Del terminal o presionándo el botón. El primero de la imagen.


Con eso, deberíamos estar más que listos para comenzar a programar -:) Copien y peguen el siguiente código…

Erlang_HANA.erl
-module(erlang_HANA).
-export([getOData/0,showInfo/5]).

showInfo(Carriers, Prices, Acc, Len, Ctr) when Ctr =< Len ->
 showInfo(Carriers, Prices,  Acc ++ [binary_to_list(lists:nth(Ctr,Carriers))] ++ [": "] ++
   [binary_to_list(lists:nth(Ctr,Prices))] ++ ["\n"], Len, Ctr + 1);
showInfo(_, _, Acc, Len, Ctr) when Ctr > Len ->
 io:format("~s",[Acc]).
 
getOData() ->
 inets:start(),
 Response = httpc:request(get, {"http://54.65.196.224:8000/Flights/flights.xsodata/FLIGHTS?$format=json", 
                          [{"Authorization", "Basic " ++ base64:encode_to_string("SYSTEM:Blag1977")}]}, [], []),
 Flights = mochijson2:decode(response_body(Response)),
 {struct, JsonData} = Flights,
 {struct, D} = proplists:get_value(<<"d">>, JsonData),
 Results = proplists:get_value(<<"results">>, D),
 Carriers = [proplists:get_value(<<"CARRNAME">>, S) || {struct, S} <- Results],
 Prices = [proplists:get_value(<<"PRICE">>, S) || {struct, S} <- Results],
 showInfo(Carriers, Prices, "", length(Carriers), 1).

response_body({ok, { _, _, Body}}) -> Body.

Guarda tu archivo y presiona el botón “Run or view the current file”. El último de la foto, que parece dos engranajes.


Debemos utilizar el formato “nombre_del:archivo:método()”para cargarlo en memoria y ejecutarlo -;)

Saludos,

Blag.
Development Culture.

Monday, November 02, 2015

Ada y HANA jugándo juntas

Este post fué posteado originalmente en Ada and HANA playing together.


Ada es un lenguaje de programación estructurado, the tipeado estático, imperativo, de amplio espectro y orientado a objetos, extendido de Pascal y otros lenguajes.

Fué desarrollado originalmente para el Departamento de Defensa de los Estados Unidos. Y fué llamado en honor a Ada Lovelace (1815-1852), quién fué la primera programadora de computadoras.

Ada es un lenguaje que simplemente no te deja fallar…puesto que posee mecanismos para revisión de código tanto en modo de compilación como de ejecución…eliminándo la gran mayoría de posibles errores molestos que se podrían generar un tu aplicación…

Así que…ninguna demostración estaría completa si la enlazaramos con SAP HANA, so? Así que…vamos a hacerlo -;)

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que ahora podemos pasar a la parte de Ada…



Ada viene instalado en la mayoría de distribuciones basadas en Linux…pero la versión puede ser un poco antigua…así que es mejor descargar e instalar una versión más actualizada…así que por favor solo hagan esto en una sesión de terminal…

sudo apt-get install gnat
sudo apt-get install libaws-bin libaws3.2.0-dev

Para instalar tanto Ada como AWS (No…no ese…Ada Web Server)…

También, necesitaremos descargar e instalar XML/Ada

tar zxvf xmlada-gpl-4.3-src.tgz
cd xmlada-4.3-src/
./configure --prefix=/usr/gnat
PROCESSORS=4 make all
make docs
make install

Luego, tenemos que actualizar el archivo .bashrc para tener las rutas correctas…

PATH=/usr/gnat/lib/gnat:$PATH
export PATH
GPR_PROJECT_PATH=/usr/gnat/lib/gnat:$GPR_PROJECT_PATH
export GPR_PROJECT_PATH

ADA_PROJECT_PATH=$ADA_PROJECT_PATH:/usr/gnat/lib/gnat
export ADA_PROJECT_PATH
ADA_OBJECTS_PATH=$ADA_OBJECTS_PATH:/usr/gnat/lib/gnat
export ADA_OBJECTS_PATH
ADA_INCLUDE_PATH=$ADA_INCLUDE_PATH:/usr/gnat/lib/gnat
export ADA_INCLUDE_PATH

Luego creamos un archivo llamado ada_hana.adb en nuestro editor favorito y copiamos el siguiente código

ada_hana.adb
with Ada.Text_IO; use Ada.Text_IO;
with AWS.Client;
with AWS.Response;

with Input_Sources.Strings;
with Unicode.CES.Utf8;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

with Sax.Readers;        use Sax.Readers;
with DOM.Readers;        use DOM.Readers;
with DOM.Core;           use DOM.Core;
with DOM.Core.Documents; use DOM.Core.Documents;
with DOM.Core.Nodes;     use DOM.Core.Nodes;
with DOM.Core.Attrs;     use DOM.Core.Attrs;

procedure Ada_Hana is
 Flights : Unbounded_String;
 Input : Input_Sources.Strings.String_Input;

 Reader : Tree_Reader;
 Doc    : Document;
 C_List   : Node_List;
 P_List   : Node_List;
 C_N      : Node;
 P_N      : Node;

begin
 Flights := AWS.Response.Message_Body (AWS.Client.Get (URL=>"http://YourServer:8000/Flights/flights.xsodata/FLIGHTS", 
                                                              User => "SYSTEM", Pwd => "YourPassword")); 
 
 Input_Sources.Strings.Open (To_String(Flights), Unicode.CES.Utf8.Utf8_Encoding, Input);
 DOM.Readers.Parse (Reader, Input);
 Doc := Get_Tree (Reader); 
 
 C_List := Get_Elements_By_Tag_Name (Doc, "d:CARRNAME");
 P_List := Get_Elements_By_Tag_Name (Doc, "d:PRICE");

   for Index in 1 .. Length (C_List) loop
      C_N := Item (C_List, Index - 1);
      P_N := Item (P_List, Index - 1);
      Put_Line (Node_Value(First_Child(C_N)) & ": " & Node_Value(First_Child(P_N)));
   end loop; 

   Free (C_List);
   Free (P_List);
   Free (Reader);
   
end Ada_Hana;

Para compilar esta aplicación debemos crear un nuevo archivo…y llamarlo compile_ada_hana.gpr

compile_ada_hana.gpr
with "aws";
project Compile_Ada_HANA is
for Main use ("ada_hana.adb");
end Compile_Ada_HANA;

Y ejecutarlo así…

sudo gprbuild compile_ada_hana.gpr

Una vez que el executable ha sido generado…podemos ejecutarlo así…

./ada_hana


Si se preguntan…porque no utilicé JSON en vez de XML? Bueno…hay una explicación sencilla para esto -:) La librería de JSON es muy buena…pero tuve algunos problemas compilándola y no hay muchos ejemplos que como extraer información de un JSON complejo…así que utilizar XML parecía una opción mejor y más sencilla -;)

Saludos,

Blag.
Development Culture.

Monday, October 26, 2015

(Defn SAP HANA [OData Clojure])

Este post fué posteado originalmente en (Defn SAP HANA [OData Clojure]).


Clojure es un lenguaje de programación dinámico que apunta a la Maquina Virtual de Java. Está diseñado para ser un lenguaje de propósito general, combinándo facilidad la y desarrollo interactivo de un lenguaje script con una estructura eficiente y robusta para programación de multi hilos.


Además…Clojure es un dialecto de Lisp, y comparte con Lisp la filosofía de código como datos y un poderoso sistemas de macros.
Así que, antes de continuar…quiero compartir un cómic de XKCD que realmente me gusta sobre Lisp -:) Y se darán cuenta de el por qué después de ver mi código fuente -;)


Así que…ninguna demostración estaría completa si la enlazaramos con SAP HANA, so? Así que…vamos a hacerlo -;)

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que ahora podemos pasar a la parte de Clojure…

La mejor forma y la más sencilla de usar Clojure es instalar Leiningen, pueden encontrar el proceso de instalación aquí.

Una vez instalado, simplemente creamos un proyecto así…

Crear Projecto
Create Project
lein new clojure_hana
cd clojure_hana
nano project.clj

Y lo modificámos para que se vea así…

project.clj
(defproject clojure_hana "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :license {:name "Eclipse Public License"
            :url "http://www.eclipse.org/legal/epl-v10.html"}
  :dependencies [[org.clojure/clojure "1.6.0"]
[clj-http "1.1.0"]
[cheshire "5.4.0"]]
:main clojure-hana.core)

Esto descargará e instalará las librerías clj-http (para trabajar con páginas web) and chesire (para trabajar con JSon) en tu proyecto.

Para programar en Clojure, pueden utilizar cualquier editor que les guste…

Dentro del folder clojure_hana, debemos hacer lo siguiente…

Crear código fuente
cd src
cd clojure_hana
nano core.clj

Copiamos y pegamos el siguiente código fuente…

core.clj
(ns clojure-hana.core
                (:require [clj-http.client :as client])
                (:require [cheshire.core :refer :all]))
 
(defn show_info [results len ctr]
                (cond
                                (or (= ctr len) (< ctr len))
                                                                (concat ((results ctr) :CARRNAME) " : " 
                                                                ((results ctr) :PRICE) "\n"
                                                                (show_info results len (inc ctr)))
                                (> ctr len)
                                                (concat "" "\n")))
 
(defn -main
  "Reads information from SAP HANA OData"
  [& args]
                (let [json (:body (client/get "http://YourHANAServer:8000/Flights/flights.xsodata/FLIGHTS?$format=json" 
                                  {:basic-auth ["YourUser" "YourPassword"]}))
                                  parsed_json (parse-string json true)
                                  results ((parsed_json :d) :results)]
                   (do(print(apply str(show_info results (dec (count results)) 0)) (symbol "")))))

Ahora lo pueden ver…Clojure es todo acerca de los paréntesis, tal como el buen viejo Lisp -:) En fín…para ejecutar el proyecto simplemente vamos hacia atrás, a la carpeta principal del proyecto clojure_hana folder y escribimos

lein run


He estado haciendo interfaces de SAP HANA OData con múltiples lenguajes…y hasta ahora…Racket había sido una de mi implementaciones más veloces…pero debo decirlo…Clojure fué aún más rápido de implementar y el código más corto -:P…aunque es un poco dificil acostumbrarse a todos esos extraños paréntesis…es un lenguaje muy bueno y poderoso…y las cosas se pueden hacer mucho más rápido de lo que uno podría imaginarse…

Saludos,

Blag.
Development Culture.

Monday, October 19, 2015

Julia, la hermana pequeña del Análisis de Datos...conoce a SAP HANA

Este post fué posteado originalmente en Julia, data analysis’s little sister...meets SAP HANA.


Julia ya no es tan joven…puesto que apareció por primera vez en el 2012 -:) Es un lenguaje de programación dinámico de alto nivel diseñado para manejar los requerimientos de computación científica y de algo performance númerico siendo al mismo tiempo efectivo para programación de propósito general.


Woaw! Esa fué una descripción bastante larga…así que...por qué debería interesárnos? Bueno…quizás porque Julia fué diseñado para ser el lenguage de programación que domine a todos…un lenguaje que puede ser utilizádo en cualquier situación que se nos presente…y sin tener que parar para decir si esto es verdad o no…debo decir que…Julia es realmente impresionante-:)

Así que…ninguna demostración estaría completa si la enlazaramos con SAP HANA, so? Así que…vamos a hacerlo -;)

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que ahora podemos pasar a la parte de Julia…

Tenemos que ir a nuestro entorno de Julia e instalar los siguientes paquetes
  • HTTPClient
  • Codecs
  • LightXML
Solo debemos hacer Pkg.add(“PackageName”) por cada uno de ellos.

Luego, debemos crear un archivo llamado Julia_HANA_XML.jl en nuestro editor favorito y copiar y pegar el siguente código...

Julia_HANA_XML.jl
using HTTPClient.HTTPC
using Codecs
using LightXML

credentials=encode(Base64,"SYSTEM:YourPassword")
Auth = bytestring(credentials)
Auth = "Basic " * Auth

flights=HTTPC.get("http://YourServer:8000/Flights/flights.xsodata/FLIGHTS",RequestOptions(headers=[("Authorization",Auth)]))

raw_text = takebuf_string(flights.body)
xdoc = parse_string(raw_text)
xroot = root(xdoc)

entry = get_elements_by_tagname(xroot,"entry")

for flights in entry
 print(content(find_element(find_element(find_element(flights,"content"),"properties"),"CARRNAME")),": ",
    content(find_element(find_element(find_element(flights,"content"),"properties"),"PRICE")),"\n")
end

Para ejecutar esta aplicación, simplemente debemos ir a Julia y escribir

Include(“Julia_HANA_XML.jl”)


Si se están preguntándo…porque no utilicé JSON en vez de XML? Bueno…Hay una explicacion muy sencilla para eso -:) De algún modo…el paquete HTTPClient tenía un problema al utilizar ?$format=json así que me vi forzado a utilizar XML…

Saludos,

Blag.
Development Culture.

Monday, October 12, 2015

Node-RED -> Node Visual con SAP HANA

Este post fué posteado originalmente en Node-RED -> Visual Node with SAP HANA.


Node-RED es una herramienta visual para manejar el Internet de las Cosas.


En otras palabras…es NodeJs con una bonita interfaz visual.

Para poder hacerlo funcionar, podemos hacer lo siguiente.

Descargar NodeJS versión 0.10.X para tu OS y arquitectura correspondientes.

Yo uso Linux y esta es la manera más practica de instalarlo…

Luego de descargar el paquete simplemente hacemos..

sudo tar -C /usr/local --strip-components 1 -xzf node-v0.10.36-linux-x86.tar.gz

Con eso, NodeJS debería estar listo y funcionando…así que es hora de Node-RED.

sudo npm install -g node-red

Tan fácil como eso -:) Ahora, simplemente debemos ejecutar node-red en el terminal y abrir un browser con 



Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


Ahora, cambiemos a la vista SAP HANA Development y creemos un nuevo repositorio. Lo llamaremos“Flights”.

Creamos un proyecto “XS Engine” y también lo llamamos “Flights”. Lo enlazamos con el repositorio “Flights”.

Creamos un archivo vacio llamado “.xsapp”.

Creamos un archivo llamado “.xsaccess” con el siguente código.

.xsaccess
{
          "exposed" : true,
          "authentication" : [ { "method" : "Basic" } ]
}

Finalmente creamos un archivo llamado “flights.xsodata” con el siguiente código

flights.xsodata
service {
          "Blag/FLIGHTS_BY_CARRIER.calculationview" as "FLIGHTS" keys 
                                                        generate local "Id";
}

Activamos el proyecto y lanzamos nuestro browser...deberíamos ver algo como esto…


La parte de SAP HANA está lista…así que podemos pasar a la parte de Node-RED…

Primero, seleccionamos el nodo http y lo llenamos con /hana en la sección del url


Ahora, seleccionamos el nodo http request node y llenamos esto en el URL


Junto con el resto de la información…


Ahora, seleccionamos el nodo Function node y lo llenamos con siguiente código fuente…


function
var results = msg.payload.d.results;
var message = "";
for (i=0;i<results.length;i++){
    var carrname = results[i].CARRNAME;
    var price = results[i].PRICE;
    message += carrname + ' : ' + price + "\n";
}
 
msg.payload = message;
return msg;


Seleccionamos un nodo template y simplemente pasamos esto…


{{payload}}


Finalmente, seleccionamos un nodo http response node y le ponemos un nombre si queremos -:)



Al final...deberíamos tener algo como esto -;)


Estamos listos -:) y dicho sea de paso…si no sienten con ganas de hacer todo esto…siempre pueden copiar este código e importarlo hacia Node-RED…

Node_RED_HANA.json
[{"id":"4ae9ba82.b51644","type":"http in","name":"","url":"/hana","method":"get",
"x":155,"y":91,"z":"3c0f3fe4.c3f0c","wires":[["ded8853e.212778"]]},{"id":"ded8853e.212778",
"type":"http request","name":"HANA","method":"GET","ret":"obj",
"url":"http://54.65.196.224:8000/Flights/flights.xsodata/FLIGHTS?$format=json",
"x":329,"y":102,"z":"3c0f3fe4.c3f0c","wires":[["c177bd31.3e884"]]},{"id":"c177bd31.3e884",
"type":"function","name":"GetInfo","func":"var results = msg.payload.d.results;
\n//var message = [];\nvar message = \"\";\nfor (i=0;i<results.length;i++){\n    
var carrname = results[i].CARRNAME;\n    var price = results[i].PRICE;\n    
//message[i] = carrname + ' : ' + price + \"\\n\"\n    message += carrname + ' : ' + 
price + \"\\n\";\n}\n\nmsg.payload = message;\nreturn msg;","outputs":1,"valid":true,
"x":507,"y":179,"z":"3c0f3fe4.c3f0c","wires":[["c59088cb.3a6f78"]]},{"id":"1995c536.e66a3b",
"type":"http response","name":"Response","x":653,"y":359,"z":"3c0f3fe4.c3f0c","wires":[]},
{"id":"c59088cb.3a6f78","type":"template","name":"Template","field":"payload",
"format":"handlebars","template":"{{payload}}","x":487,"y":321,"z":"3c0f3fe4.c3f0c",
"wires":[["1995c536.e66a3b"]]}]


Para ejecutarlo…simplemente seleccionen “Deploy” y vayan hacia http://localhost:1880/hana


Asombrosamente sencillo, no? -:)

Saludos,

Blag.
Development Culture.

Monday, October 05, 2015

Hasta los niños pueden jugar con SAP HANA

Este post fué posteado originalmente en Even kids can play with SAP HANA.


Small Basic es un lenguaje de programación creado por Microsoft y está basado en el lenguaje BASIC. Está orientado a enseñar a niños como programar y tiene un excelente Syntax Highlighting, Completado Inteligente de Código y acceso a documentación dentro del editor. Encima de todo eso…el lenguaje tiene solamente 14 palabras reservadas.



Small Basic viene con un muy bonito y simple IDE…




Y el Completado de Código es simplemente maravilloso y muy bien documentado.

Para poder acceder a SAP HANA via ODBC necesitamos descargar una asombrosa librería llamada LitDev.

Solamente extrae y copia el DLL y el XML a un folder llamado “lib” dentro de tu instalación de Small Basic. Si tiene algún problema, simplemente haz click derecho en LitDev.dll y liberalo "unlock it".

Bueno…ningún ejemplo o documentación estaría completa si no lo enlazaramos con SAP HANA, no es verdad? Así que…vamos a hacerlo -;) (Esta parte no es exactamente amigable para niños…así que busca la ayuda de un adulto)…

Primero, debemos crear un objeto Join y asociar la tabla por MANDT y CARRID. De ahí, seleccionar los siguientes campos como output MANDT, CARRID, CARRNAME, PRICE y CURRENCY.

Luego crear un objeto Aggregation seleccionándo los campos CARRNAME, PRICE (Como columnas agregadas) y CURRENCY. Debemos filtrar el campo CURRENCY por ‘USD’.

Luego, debemos crear un objeto Projection y seleccionar solo PRICE y CARRNAME.

En el objeto Semantics asegúrense de marcar  “CROSS CLIENT” como cliente por defecto.


La parte de SAP HANA está lista…así que ahora podemos movernos a la parte de Small Basic…

Ahora, simplemente debemos de crear un nuevo archivo y copiar y pegar el siguiente código…

HANA.sb
LDDataBase.Connection="DRIVER={HDBODBC};SERVERNODE=YourServer:30015;
DATABASE=SYSTEM;UID=YouUser;PWD=YourPassword"
Db = LDDataBase.ConnectOdbc("","","","","",0,"")
GraphicsWindow.Show()
Lv = LDDataBase.AddListView(GraphicsWindow.Width,GraphicsWindow.Height)
Quote = Text.GetCharacter(34)
Query = "SELECT * FROM" + Quote + "_SYS_BIC" + Quote + "." + Quote + "Blag/FLIGHTS_BY_CARRIER" + Quote
LDDataBase.Query(Db,Query, Lv, "False")

Reemplaza Blag con tu propio nombre de paquete -:)

Sencillo, no?


Ahí está…ahora hasta los niños pueden aprovechar el poder de SAP HANA -;)

Saludos,

Blag.
Development Culture.