@sap/xsodata/lib/sql/dataCollectorPut.js

Expose data from a HANA database as OData V2 service with help of .xsodata files.

'use strict';

//Include
const dataCollector2 = require('./dataCollector2');
const sqlStatement = require('./sqlStatement');
const statementProcessor = require('./statementProcessor');
const utils = require('../utils/utils');
const SqlError = require('../utils/errors/sqlError');

exports.moveRecordNV_ToInsertTmpStm = function (context, asyncDone) {
    context.logger.silly('dataCollector', 'moveRecordNV_ToInsertTmpStm');
    //get dbSegment for inserting the payload
    const dbSeg = context.oData.dbSegmentLast;
    const stm = dbSeg.sql.stmContainer.insertTmp;
    if (!stm) {
        return asyncDone('Internal server error', context);
    }

    for (const nv of dbSeg._recordNV) {
        stm.setValue(
            nv.name,
            nv.value,
            dbSeg.entityType.propertiesMap[nv.name].DATA_TYPE_NAME
        ); // OK
    }
    return asyncDone(null, context);
};

exports.createTmpTables = function (context, asyncDone) {
    const dbSeg = context.oData.dbSegmentLast;
    const stms = [
        dbSeg.sql.stmContainer.createTmpOld,
        dbSeg.sql.stmContainer.createTmp,
    ];
    return statementProcessor.execStmsDirectlyNoResult(
        context,
        stms,
        asyncDone
    );
};

exports.checkForAutoKeyGenUsage = function (context, asyncDone) {
    context.logger.silly('dataCollectorPut', 'checkForAutoKeyGenUsage');

    const dbSeg = context.oData.dbSegmentLast;
    if (!dbSeg.entityType.hasAdmindata()) {
        return asyncDone(null, context);
    }

    const stm = dbSeg.sql.stmContainer.insertTmp;
    const appData = {};
    const nv = stm.nv;
    let name = '';

    const createBy = dbSeg.entityType.getAddAdmindata('create', 'by');
    const createAt = dbSeg.entityType.getAddAdmindata('create', 'at');
    const modifyBy = dbSeg.entityType.getAddAdmindata('modify', 'by');
    const modifyAt = dbSeg.entityType.getAddAdmindata('modify', 'at');

    for (const elem of nv) {
        name = elem.name.toSqlHana(null, null, { withoutTable: true });
        name = name.slice(1, -1);
        appData[name] = {
            value: elem.value,
            sequence: null,
        };

        if (modifyBy && name === 'MODIFIED_BY') {
            // overwrites .formula .sequence and .value
            elem.overwriteValue = new sqlStatement.Value(context.userName);
        }
        if (modifyAt && name === 'MODIFIED_AT') {
            elem.formula = 'NOW()';
        }
    }

    if (!(createBy || createAt)) {
        return asyncDone(null, context);
    }

    return insertOldDataToOldTable(context, asyncDone);
};

const insertOldDataToOldTable = function (context, asyncDone) {
    context.logger.silly('dataCollectorPost', 'insertOldDataToOldTable');

    const dbSeg = context.oData.dbSegmentLast;
    const stm = dbSeg.sql.stmContainer.selectCreateInfoFromTmpOld;
    const nv = dbSeg.sql.stmContainer.insertTmp.nv;
    let name;

    const createBy = dbSeg.entityType.getAddAdmindata('create', 'by');
    const createAt = dbSeg.entityType.getAddAdmindata('create', 'at');

    const p = [];
    const sql = stm.toSqlHana(new sqlStatement.SqlBuildHanaContext(context), p);

    dataCollector2.executeSqlAsPreparedStatement(
        context,
        sql,
        p,
        (err, rows) => {
            if (err) {
                context.logger.info(
                    'SQL Exec',
                    'Error: \n' + JSON.stringify(err)
                );
                context.logger.info('SQL Exec', 'SQL: \n' + sql);
                return asyncDone(new SqlError(context, err), context);
            }

            context.logger.silly(
                'selectData',
                'rows: ' + JSON.stringify(rows.length)
            );

            for (const element of nv) {
                name = element.name.toSqlHana(null, null, {
                    withoutTable: true,
                });
                name = name.substr(1, name.length - 2);

                if (createBy && name === 'CREATED_BY') {
                    element.value = new sqlStatement.Value(rows[0].CREATED_BY);
                }
                if (createAt && name === 'CREATED_AT') {
                    element.value = new sqlStatement.Value(rows[0].CREATED_AT);
                }
            }
            return asyncDone(null, context);
        }
    );
};

exports.insertOldDataToOldTable = function (context, asyncDone) {
    const dbSeg = context.oData.dbSegmentLast;
    return statementProcessor.execStmsAsPreparedNoResult(
        context,
        dbSeg.sql.stmContainer.insertTmpOld,
        asyncDone
    );
};

exports.moveCreatedInfoToNewTempTable = function (context, asyncDone) {
    const dbSeg = context.oData.dbSegmentLast;
    statementProcessor.execStmsAsPreparedNoResult(
        context,
        dbSeg.sql.stmContainer.updateTmpCreateInfo,
        asyncDone
    );
};

exports.insertPayloadIntoTempTable = function (context, asyncDone) {
    context.logger.silly('dataCollectorPut', 'insertPayloadIntoTempTable');
    const dbSeg = context.oData.dbSegmentLast;
    statementProcessor.execStmsAsPreparedNoResult(
        context,
        dbSeg.sql.stmContainer.insertTmp,
        asyncDone
    );
};

exports.insertTmpTableToRealTable = function (context, asyncDone) {
    context.logger.silly('dataCollectorPut', 'insertTmpTableToRealTable');
    const dbSeg = context.oData.dbSegmentLast;

    statementProcessor.execStmsAsPrepared(
        context,
        [dbSeg.sql.stmContainer.updateReal],
        (err, context, resultset) => {
            if (err) {
                return asyncDone(err, context);
            }
            return dataCollector2.resultSetCheckRowCountForUpdate(
                context,
                resultset,
                0,
                1,
                asyncDone
            );
        }
    );
};

exports.selectData = function (context, asyncDone) {
    context.logger.silly('dataCollectorPost', 'selectData');
    const dbSeg = context.oData.dbSegmentLast;
    const stm = dbSeg.sql.stmContainer.selectFromTmp;

    const p = [];
    const sql = stm.toSqlHana(new sqlStatement.SqlBuildHanaContext(context), p);
    dataCollector2.executeSqlAsPreparedStatement(
        context,
        sql,
        p,
        (err, rows) => {
            dbSeg.sql.rows = rows;
            if (
                rows.length === 1 &&
                utils.isETagHeaderRequired(context, dbSeg)
            ) {
                dbSeg.etagHeader = rows[0].__etag;
            }
            return asyncDone(null, context);
        }
    );
};

exports.commit = function (context, asyncDone) {
    context.logger.debug('dataCollectorPut', 'commit');
    if (context.batchContext) {
        //When running in batch the commit is performed by the batch executor
        return asyncDone(null, context);
    }

    const client = context.db.client;
    client.commit(function (err) {
        if (err) {
            context.logger.info(
                'SQL Exec',
                'Commit Error: \n' + JSON.stringify(err)
            );
            return asyncDone(err, context);
        }
        return asyncDone(null, context);
    });
};

/**
 * Executes truncation of temporary created tables
 *
 * @param {Object} context The xsodata context
 * @param {Function} asyncDone async waterfall callback
 */
exports.truncateTempTables = function (context, asyncDone) {
    let statements;
    context.logger.silly('dataCollectorPut', 'truncateTempTables');

    statements = [
        context.sql.container.createTmpTruncate,
        context.sql.container.createTmpOldTruncate,
    ];
    return statementProcessor.execTempTableStatements(
        context,
        statements,
        asyncDone
    );
};

/**
 * Executes deletion of temporary created tables
 *
 * @param {Object} context The xsodata context
 * @param {Function} asyncDone async waterfall callback
 */
exports.dropTempTables = function (context, asyncDone) {
    let statements;
    context.logger.silly('dataCollectorPut', 'dropTempTables');

    statements = [
        context.sql.container.createTmpDrop,
        context.sql.container.createTmpOldDrop,
    ];

    return statementProcessor.execTempTableStatements(
        context,
        statements,
        asyncDone
    );
};