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

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

'use strict';

const sql = require('./sqlStatement');
const sqlTools = require('./sqlTools');
const utils = require('../utils/utils');
const EntityType = require('../model/entityType.js');

exports.createPostStatementsForCreateTmpTables = function (context, asyncDone) {
    try {
        context.logger.silly(
            'createPostStatements',
            'createPostStatementsForCreateTmpTables'
        );
        const dbSegLast = context.oData.dbSegmentLast;

        const sqlContext = {
            context: context,
            netId: context.uniqueNetworkRequestID,
            reqId: context.uniqueRequestID,
            rId: 1,
            dbSegLast: dbSegLast,
            systemQueryParameters: context.oData.systemQueryParameters,
        };

        context.sql = sqlContext;
        context.sql.container = dbSegLast.sql.stmContainer =
            new sql.PostContainer();

        startPostMasterDbSegForCreate(sqlContext);
        return asyncDone(null, context);
    } catch (err) {
        return asyncDone(err, context);
    }
};

exports.createPostStatementsForInsert = function (context, asyncDone) {
    try {
        context.logger.silly(
            'createPostStatements',
            'createPostStatementsForInsert'
        );

        const sqlContext = context.sql;

        startPostMasterDbSegForInsert(sqlContext);
        return asyncDone(null, context);
    } catch (err) {
        return asyncDone(err, context);
    }
};

/**
 * Create SQL statements for the master table (=end of resource path)
 * @param sqlContext
 */
function startPostMasterDbSegForCreate(sqlContext) {
    const dbSeg = sqlContext.dbSegLast;

    sqlContext.context.logger.debug(
        'createPostStatements',
        'startPostMasterDbSegForCreate'
    );

    dbSeg.sql.rId = sqlTools.rIdToNewTableName(
        dbSeg._Alias,
        sqlContext.netId,
        sqlContext.reqId,
        sqlContext.rId++
    );

    //create statement for master table
    dbSeg.sql.stmContainer.createTmp = masterTableCreate(
        sqlContext,
        dbSeg.sql.rId
    );
}

/**
 * Create SQL statements for the master table (=end of resource path)
 * @param sqlContext
 */
function startPostMasterDbSegForInsert(sqlContext) {
    const dbSeg = sqlContext.dbSegLast;

    sqlContext.context.logger.debug(
        'createPostStatements',
        'startPostMasterDbSegForInsert'
    );

    //create insert statement for master table
    dbSeg.sql.stmContainer.insertTmp = masterTableInsertTmp(
        sqlContext,
        dbSeg.sql.rId
    );

    //create insert statement for master table
    dbSeg.sql.stmContainer.insertReal = masterTableInsert(
        sqlContext,
        dbSeg.sql.rId
    );

    //create select statement for master table
    dbSeg.sql.stmContainer.select = masterTableSelect(
        sqlContext,
        dbSeg.sql.rId
    );

    if (sqlContext.context.db.isExternalHandledConnection === true) {
        // We only truncate and delete temp tables when db connection is handled external
        // otherwise we will self disconnect and temp tables will be deleted automatically

        // Build the truncate statement for created temporary table;
        dbSeg.sql.stmContainer.createTmpTruncate = sql.buildTableStatement(
            sql.Truncate,
            sqlContext,
            dbSeg.sql.stmContainer.createTmp.table
        );
        sqlContext.context.networkContext.cleanSessionTruncateContainer.push(
            dbSeg.sql.stmContainer.createTmpTruncate
        );

        // Build the drop statement for created temporary table;
        dbSeg.sql.stmContainer.createTmpDrop = sql.buildTableStatement(
            sql.Drop,
            sqlContext,
            dbSeg.sql.stmContainer.createTmp.table
        );
        sqlContext.context.networkContext.cleanSessionDropContainer.push(
            dbSeg.sql.stmContainer.createTmpDrop
        );
    }
}

function masterTableCreate(sqlContext, rId) {
    const context = sqlContext.context;
    const dbSeg = sqlContext.dbSegLast;
    const stmCreate = new sql.Create();

    context.logger.debug(
        'createPostStatements',
        'masterTableCreate (ordered selects)'
    );
    stmCreate.setModifiers([
        'local',
        'temporary',
        dbSeg.entityType.tableStoreType,
    ]);
    stmCreate.setTableName(rId);

    const properties = dbSeg.getPropertiesForCreate();
    const propertiesDbOrdered = dbSeg.makeDbOrdered(properties);
    stmCreate.addProperties(propertiesDbOrdered);
    if (dbSeg._ExpandedNavigations.length > 0) {
        stmCreate.addProperties(dbSeg.getNavPropertiesForCreate());
    }
    return stmCreate;
}

function masterTableInsertTmp(sqlContext, rId) {
    const context = sqlContext.context;
    const dbSeg = sqlContext.dbSegLast;
    const stm = new sql.Insert();

    context.logger.debug(
        'createPostStatements',
        'masterTableInsertTmp (ordered selects)'
    );
    stm.setTableName({ table: rId });
    //SELECT

    const properties = dbSeg.getQKeyProperties();
    const all = properties.concat(dbSeg.getQNonKeyProperties());
    const allOrdered = dbSeg.makeDbOrdered(all);

    stm.addNames(allOrdered);

    //the data is inserted later on
    return stm;
}

function masterTableInsert(sqlContext, rId) {
    sqlContext.context.logger.debug(
        'createPostStatements',
        'createPostSQL_Insert_TmpMasterTable (ordered selects)'
    );
    const dbSeg = sqlContext.dbSegLast;

    //subselect
    const subSelect = new sql.Select();
    subSelect.addSelects(new sql.SelectFormula(null, '*'));
    subSelect.setFrom({ schema: null, table: rId, alias: null });

    const stm = new sql.Insert();
    //SELECT

    stm.setTableName(dbSeg.getQTableNameNoAlias());

    const properties = dbSeg.getQKeyProperties();
    const all = properties.concat(dbSeg.getQNonKeyProperties());
    const allOrdered = dbSeg.makeDbOrdered(all);
    stm.addNames(allOrdered);

    //Values
    stm.setSubSelect(subSelect);
    return stm;
}

/**
 * Create select SQL statement to select from tmp table
 * Since a application exit may be used to do the insert into the real table
 * and possible create a custom key, we can't select with the client-key from the real table
 * so in this case the application has the possiblity to pass the new key back to the client.
 * @param sqlContext
 * @param rId
 * @returns {Select}
 */
function masterTableSelect(sqlContext, rId) {
    sqlContext.context.logger.debug(
        'createPostStatements',
        'masterTableSelect (ordered selects)'
    );
    const dbSeg = sqlContext.dbSegLast;

    const stmSelect = new sql.Select();

    stmSelect.addSelect(dbSeg.getQKeyPropertiesWith0123AliasForSelect(true));
    let prop = null;
    if (
        dbSeg.entityType.kind === EntityType.entityKind.calculationView &&
        dbSeg.entityType._entityType.parameters &&
        dbSeg.entityType._entityType.parameters.viaKey === true
    ) {
        prop = dbSeg.getSelectFragmentsFromAllProperties(true);
    } else {
        prop = dbSeg.getPropertiesForSelect(true);
    }

    const propOrdered = dbSeg.makeDbOrdered(prop);
    stmSelect.addSelects(propOrdered);

    if (dbSeg._ExpandedNavigations.length > 0) {
        stmSelect.addSelects(dbSeg.getNavPropertiesForSelect(true));
    }

    if (utils.isETagRequired(sqlContext.context, dbSeg)) {
        sql._addETagToSelect(dbSeg, stmSelect, rId);
    }

    stmSelect.setFrom({ schema: null, table: rId, alias: null });
    return stmSelect;
}