@sap/hana-client

What is @sap/hana-client?

@sap/hana-client is an npm package that provides a client interface for connecting to and interacting with SAP HANA databases. It allows developers to execute SQL queries, manage database connections, and handle transactions programmatically.

What are @sap/hana-client's main functionalities?

Connecting to SAP HANA

This feature allows you to establish a connection to an SAP HANA database using the provided connection parameters.

const hana = require('@sap/hana-client');
const conn = hana.createConnection();
const connParams = {
  serverNode: 'myServer:30015',
  uid: 'myUser',
  pwd: 'myPassword'
};
conn.connect(connParams, (err) => {
  if (err) throw err;
  console.log('Connected to SAP HANA');
});

Executing SQL Queries

This feature allows you to execute SQL queries against the connected SAP HANA database and retrieve the results.

const sql = 'SELECT * FROM MY_TABLE';
conn.exec(sql, (err, result) => {
  if (err) throw err;
  console.log(result);
});

Handling Transactions

This feature allows you to manage transactions by explicitly committing or rolling back changes to the database.

conn.setAutoCommit(false);
conn.exec('INSERT INTO MY_TABLE (ID, NAME) VALUES (1, 'John Doe')', (err) => {
  if (err) {
    conn.rollback();
    throw err;
  }
  conn.commit((err) => {
    if (err) throw err;
    console.log('Transaction committed');
  });
});

Other packages similar to @sap/hana-client

mysql

The 'mysql' package provides a client interface for connecting to MySQL databases. It offers similar functionalities such as executing SQL queries, managing connections, and handling transactions. However, it is specific to MySQL databases, whereas @sap/hana-client is specific to SAP HANA.

pg

The 'pg' package is a PostgreSQL client for Node.js. It allows developers to connect to PostgreSQL databases, execute SQL queries, and manage transactions. Like @sap/hana-client, it provides a robust set of features for database interaction, but it is tailored for PostgreSQL.

mssql

The 'mssql' package is a Microsoft SQL Server client for Node.js. It provides functionalities for connecting to SQL Server databases, executing queries, and handling transactions. It is similar to @sap/hana-client in terms of features but is designed for use with SQL Server.

README

#@sap/hana-client This is a Node.js driver written for SAP HANA.

##Install

npm install @sap/hana-client

####Prerequisites

This driver communicates with the native HANA libraries, and thus requires platform-specific native binaries. Native compilation is managed by node-gyp. Please see that project for additional prerequisites including Python 2.7, and C/C++ tool chain.

The official hosted version includes precompiled libraries for Linux, Windows and Mac OS X.

The @sap/hana-client driver supports node.js 4.x, 6.x, 8.x and 10.x.

##Getting Started

var hana = require('@sap/hana-client');

var conn = hana.createConnection();

var conn_params = {
  serverNode  : 'myserver:30015',
  uid         : 'system',
  pwd         : 'manager'
};

conn.connect(conn_params, function(err) {
  if (err) throw err;
  conn.exec('SELECT Name, Description FROM Products WHERE id = ?', [301], function (err, result) {
    if (err) throw err;

    console.log('Name: ', result[0].Name, ', Description: ', result[0].Description);
    // output --> Name: Tee Shirt, Description: V-neck
    conn.disconnect();
  })
});

##Establish a database connection ###Connecting A database connection object is created by calling createConnection. The connection is established by calling the connection object's connect method, and passing in an object representing connection parameters.

#####Example: Connecting over TCP/IP

conn.connect({
  host    : 'myserver',
  port    : '30015',
  uid     : 'system',
  pwd     : 'manager'
});

###Disconnecting

conn.disconnect(function(err) {
  if (err) throw err;
  console.log('Disconnected');
});

##Direct Statement Execution Direct statement execution is the simplest way to execute SQL statements. The inputs are the SQL command to be executed, and an optional array of positional arguments. The result is returned using callbacks. The type of returned result depends on the kind of statement.

####DDL Statement

In the case of a successful DDL Statement nothing is returned.

conn.exec('CREATE TABLE Test (id INTEGER PRIMARY KEY, msg VARCHAR(128))', function (err, result) {
  if (err) throw err;
  console.log('Table Test created!');
});

####DML Statement

In the case of a DML Statement the number of affectedRows is returned.

conn.exec("INSERT INTO Test VALUES(1, 'Hello')", function (err, affectedRows) {
  if (err) throw err;
  console.log('Number of affected rows:', affectedRows);
});

####Query

The exec function is a convenient way to completely retrieve the result of a query. In this case all selected rows are fetched and returned in the callback.

conn.exec("SELECT * FROM Test WHERE id < 5", function (err, rows) {
  if (err) throw err;
  console.log('Rows:', rows);
});

Values in the query can be substitued with JavaScript variables by using ? placeholders in the query, and passing an array of positional arguments.

conn.exec("SELECT * FROM Test WHERE id BETWEEN ? AND ?", [5, 8], function (err, rows) {
  if (err) throw err;
  console.log('Rows:', rows);
});

##Prepared Statement Execution ####Prepare a Statement The connection returns a statement object which can be executed multiple times.

conn.prepare('SELECT * FROM Test WHERE id = ?', function (err, stmt){
  if (err) throw err;
  // do something with the statement
});

####Execute a Statement The execution of a prepared statement is similar to the direct statement execution. The first parameter of exec function is an array with positional parameters.

stmt.exec([16], function(err, rows) {
  if (err) throw err;
  console.log("Rows: ", rows);
});

####Execute a Batch Statement The execution of a prepared batch statement is similar to the direct statement execution. The first parameter of execBatch function is an array with positional parameters.

var stmt=conn.prepare("INSERT INTO Customers(ID, NAME) VALUES(?, ?)");
stmt.execBatch([[1, 'Company 1'], [2, 'Company 2']], function(err, rows) {
  if (err) throw err;
  console.log("Rows: ", rows);
});

####Execute a Query The execution of a prepared query is similar to the direct statement execution. The first parameter of execQuery function is an array with positional parameters.

var stmt=conn.prepare("SELECT * FROM Customers WHERE ID >= ? AND ID < ?");
stmt.execQuery([100, 200], function(err, rs) {
  if (err) throw err;
    var rows = [];
    while (rs.next()) {
	rows.push(rs.getValues());
    }
  console.log("Rows: ", rows);
});

####Drop Statement

stmt.drop(function(err) {
  if (err) throw err;
});

##Transaction Handling Transactions are automatically commited. Setting autocommit to false implicitly starts a new transaction that must be explicitly committed, or rolled back.

####Commit a Transaction

conn.setAutoCommit(false);
// Execute some statements
conn.commit(function(err) {
  if (err) throw err;
  console.log('Transaction commited.');
});

####Rollback a Transaction

conn.setAutoCommit(false);
// Execute some statements
conn.rollback(function(err) {
  if (err) throw err;
  console.log('Transaction rolled back.');
});

##Resources

• SAP HANA Documentation
• SAP HANA Forum
• SAP HANA Community