"ORA-01756: quoted string not properly terminated"

Question

Speak guys, good morning, I’m with a legacy code and I’m having the following difficulty:

When I try to check any word that has simple quotation mark I get this error ORA-01756

Ex: Raphael me'lo

now when I try:

Ex: Raphael me'lo

I don’t get such a mistake, but I’m not getting to understand where he’s doing such a check:

follows the code line:

words-undue.model.js:

'use strict';

class PalavrasIndevidas {
    constructor(listaPalavrasIndevidas = []) {
        this.listaPalavrasIndevidas = listaPalavrasIndevidas;
    }
}

try { module.exports = exports = PalavrasIndevidas } 
catch (e) { exports = PalavrasIndevidas }

improper words.service.js:

'use strict';

// constants
const routeCreator = require('../../../../../common/route-creator')();

// support methods
const SuporteOperacoes = require(`${config.paths.app}/comum/suporte.operacoes`);

// repository patterns
const PalavrasIndevidasRepository = require('./palavras-indevidas.persistence');

// model domains
const PalavrasIndevidas = require('./palavras-indevidas.model');

class PalavrasIndevidasService {
     constructor(appContext, httpOptions) {
        this._context = appContext;
        this._options = JSON.parse(JSON.stringify(httpOptions));

        let servicePath = `${httpOptions.getLocalPathPBase()}/sistema/palavras-indevidas`;
        let palavrasIndevidasRepository = new PalavrasIndevidasRepository();

        this._getPalavrasIndevidas = (req, res) => {
			let palavrasIndevidas = new PalavrasIndevidas();
			//var palavrasIndevidas = null;
			
			//palavrasIndevidas = req.query;
			if(typeof req.query.listaPalavrasIndevidas == "string") palavrasIndevidas.listaPalavrasIndevidas = [req.query.listaPalavrasIndevidas];
			if(req.query.listaPalavrasIndevidas instanceof Array) palavrasIndevidas.listaPalavrasIndevidas = req.query.listaPalavrasIndevidas;
			//let palavrasIndevidas = req.body

			palavrasIndevidasRepository.listarPalavrasIndevidas(palavrasIndevidas, lista => {
				res.send( lista );
				res.end();
			});
		};

        this._postPalavrasIndevidas = (req, res) => {
			palavrasIndevidasRepository.manterPalavrasIndevidas(req.body, mensagemRetorno => {
				res.send(SuporteOperacoes.deParaMensagemDB(mensagemRetorno));
				res.end();
			});
		};

        this._verificarPalavraIndevida= (req, res) => {
            global.log.info(__filename.split('/').reverse()[0]+' \nVerificar Palavras indevidas', req.query);
            let txt = httpOptions.mapObject(req);
            console.log(txt);
            

            var array = [];

            let textoDecodificado = decodeURIComponent(txt.texto);

            array = textoDecodificado.split(" ");
            
            palavrasIndevidasRepository.palavrasEncontradas(array, res, (lista) => {
                res.send(lista);
                res.end();
            });
        }
        
		routeCreator.bind(this._context, this._options.verbEnum.GET, servicePath, this._getPalavrasIndevidas);

        routeCreator.bind(this._context, this._options.verbEnum.POST, `${servicePath}/ope`, this._postPalavrasIndevidas);
     
        routeCreator.bind(this._context, this._options.verbEnum.GET, servicePath + "/validar-texto", this._verificarPalavraIndevida);

    }
}

module.exports = exports = PalavrasIndevidasService;

words-undue.persistence.js:

'use strict';

// libs
const oracledb = require('oracledb');

// common
const dbEngine = new require('../../../../../common/database-connector')();
const dbConstants = require('../../../../../common/database-constants');

// model domains
const Mensagem = require('../../comum/mensagem.model');
const Motivo = require('../../comum/motivo.model');
const Situacao = require('../../comum/situacao.model');
const Registro = require('../../comum/registro.model');
const PalavrasIndevidas = require('./palavras-indevidas.model');
let SbeUtil = require('../../../../../common/sbe-util');

const c_COMMAND_LISTAR = "BEGIN :cursor := SBE.KSBE_PARAMETRIZACAO_PORTAL.LISTAR_PALAVRA_INDEVIDA(p_lst_palavra_indevida => :p_lst_palavra_indevida); END;";
const c_COMMAND_MANTER = "SBE.KSBE_PARAMETRIZACAO_PORTAL.manter_palavra_indevida(p_lst_palavra_indevida, :p_msg_sistemica); END;";
const c_COMMAND_VALIDAR = " v_Return := SBE.KSBE_PARAMETRIZACAO_PORTAL.listar_palavra_indevida(p_lst_palavra_indevida => p_lst_palavra_indevida); :cursor := v_Return; END;";

class PalavrasIndevidasRepository {
    listarPalavrasIndevidas (palavrasIndevidas, callback) {

		if(!palavrasIndevidas.listaPalavrasIndevidas instanceof Array){
			callback(new Mensagem(null, '10', 'parâmetro inválido - listaPalavrasIndevidas', new Date(), null, null));
			return false;
		}
		
		if(palavrasIndevidas.listaPalavrasIndevidas.length == 0){
			callback(new Mensagem(null, '10', 'parâmetro inválido - listaPalavrasIndevidas', new Date(), null, null));
			return false;
		}
		
        const bindVars = {
			p_lst_palavra_indevida: { val: palavrasIndevidas.listaPalavrasIndevidas, type: oracledb.DB_TYPE_CLOB, dir: oracledb.BIND_IN },
			cursor: { type: oracledb.CURSOR, dir: oracledb.BIND_OUT, maxSize: 2 }			
        };

        try 
		{
			//global.log.info(__filename+" sqlCommand: " + c_COMMAND_LISTAR);
			//global.log.info(__filename+" body: "+ JSON.stringify(palavrasIndevidas));
			dbEngine.execute(c_COMMAND_LISTAR, dbConstants.PROC_OUT, bindVars, callbackDB);
        } 
		catch (error) 
		{
          global.log.error(__filename.split('/').reverse()[0]+' \nlistarPalavrasIndevidas', error);
          callback(new Mensagem(null, '10', 'Erro na execução do serviço', new Date(), null, null));
        }

        function callbackDB(connection, resultSet, numRows) {
			let objRetorno = new PalavrasIndevidas();
			try
			{
				resultSet.getRows( // get numRows rows
					numRows,
					function (err, rows) 
					{
						if (err) 
						{
							global.log.error(__filename.split('/').reverse()[0]+' \nPalavrasIndevidasRepository.listarPalavrasIndevidas.callbackDB', err);
							dbEngine.doClose(connection, resultSet); // always close the result set
							callback(new Mensagem(null, '10', 'Erro na execução do serviço', new Date(), null, null));
							return false;
						} 
						else if (rows.length === 0) 
						{    // no rows, or no more rows
							callback(new Mensagem(null, '8', 'Não há registro retornado na pesquisa.', new Date(), null, null));
							dbEngine.doClose(connection, resultSet); // always close the result set
							return false;
						} else if (rows.length > 0) 
						{
							for (var i = 0; i < rows.length; i++) 
							{
								var strPalavraIndevida = rows[i][0];
								objRetorno.listaPalavrasIndevidas.push(strPalavraIndevida);
							}
							dbEngine.doClose(connection, resultSet); // always close the result set
							callback(objRetorno);
							return true;
						}
					}
				);
			}
			catch(error)
			{
				global.log.error(__filename.split('/').reverse()[0]+' \nlistarPalavrasIndevidas', error);
				callback(new Mensagem(null, '10', 'Erro na execução do serviço', new Date(), null, null));
				return false;
			}
			return true;
        }    
    }

    manterPalavrasIndevidas (palavrasIndevidas, callback) {

    	let itemMapArr = [];
    	palavrasIndevidas.listaPalavrasIndevidas.forEach((item) => {
            itemMapArr.push("'" + item + "'");
        });
    	
    	let listaSQL = SbeUtil.convertArrayToPlSql(itemMapArr, 'p_lst_palavra_indevida');

        let sqlAction = "DECLARE p_lst_palavra_indevida SBE.KSBE_PARAMETRIZACAO_PORTAL.LISTA_PALAVRA_INDEVIDA_TYPE; BEGIN "
            + listaSQL + " " + c_COMMAND_MANTER;
    	
        const bindVars = {
            p_msg_sistemica:  { type: oracledb.STRING, dir: oracledb.BIND_OUT }
        };

        try { 
			global.log.info(__filename+" sqlCommand: " + sqlAction);
			global.log.info(__filename+" bindVars: "+ JSON.stringify(bindVars));			
            dbEngine.execute(sqlAction, dbConstants.MERGE, bindVars, callbackDB);
        }
        catch (error) {

            global.log.error(__filename.split('/').reverse()[0]+' \nmanterPalavrasIndevidas', error);
			
            callback(new Mensagem(null, '10', 'Erro na execução do serviço', new Date(), null, null));
        }

        function callbackDB(connection, result, mensagemRetorno) {
            try {
                if (mensagemRetorno.codigo === 0) {
                    mensagemRetorno.codigo = result.p_msg_sistemica;
                } else 
				{
                    mensagemRetorno.mensagem = 'Erro na execução do serviço';
                }

                dbEngine.doRelease(connection);
                callback(mensagemRetorno);
            } catch (err) {
                global.log.error(__filename.split('/').reverse()[0]+' \nmanterPalavrasIndevidas.callbackDB', err);
                callback(new Mensagem(null, '10', 'Erro na execução do serviço', new Date(), null, null));
            }
        }
    }

	palavrasEncontradas(listaPalavras, res, callback) {
        let palavrasIndevidasEncontradas = [];
        
        var bindVars = null;
        var bindVars = {
            cursor: { dir: oracledb.BIND_OUT, type: oracledb.CURSOR, maxSize: 2 }
        };

        let itemMapArr = [];
        listaPalavras.forEach((item) => {
            itemMapArr.push("'" + item + "'");
        });

        let listaSQL = SbeUtil.convertArrayToPlSql(itemMapArr, 'p_lst_palavra_indevida');

        let sqlAction = "DECLARE p_lst_palavra_indevida SBE.KSBE_PARAMETRIZACAO_PORTAL.LISTA_PALAVRA_INDEVIDA_TYPE; v_Return SYS_REFCURSOR; BEGIN "
            + listaSQL + " " + c_COMMAND_VALIDAR;
        try {
            dbEngine.execute(sqlAction, dbConstants.SELECT, bindVars, callbackDB, false, true);
        } catch (error) {
            global.log.error(__filename.split('/').reverse()[0]+' \npalavrasEncontradas', error);
            res.status(422);
            callback(
                new Mensagem(null, '10', 'Erro na execução do serviço', new Date(), "palavrasEncontradas", null)
            );
        }

        function callbackDB(connection, resultSet, numRows) {
            global.log.info(__filename.split('/').reverse()[0]+' \nno metodo callbackDB');
            try {
                resultSet.getRows( // get numRows rows
                    numRows,
                    function (err, rows) {
                        if (err) {
                            global.log.error(__filename.split('/').reverse()[0]+' \npalavrasEncontradas.callbackDB', err);
                            global.log.error(err, numRows);
                            callback(
                                new Mensagem(null, '10', 'testinho mais top ainda', new Date(), 'palavrasEncontradas.callbackDB', { err: err, oracleErro: numRows })
                            );
                        } else if (rows.length === 0) { // no rows, or no more rows
                            callback(palavrasIndevidasEncontradas);
                            dbEngine.doClose(connection, resultSet); // always close the result set
                        } else if (rows.length > 0) {
                            palavrasIndevidasEncontradas = rows.map((row) => row.DE_PALAVRA_INDEVIDA);
                            callbackDB(connection, resultSet, numRows);
                        }
                    });
            } catch (e) {
                global.log.error(__filename.split('/').reverse()[0]+' \npalavrasEncontradas.callbackDB', numRows, e.stack);
                global.log.error(e);
                global.log.error(numRows);
                res.status(422);
                callback(
                    new Mensagem(null, numRows.codigo || '10', 'testinho top', new Date(), 'palavrasEncontradas.callbackDB', { javascriptErro: e.message, oracleErro: numRows })
                );
            }
        }
    }
}

module.exports = exports = PalavrasIndevidasRepository;

I am grateful in advance.

Answer 1

The content between single quotes identifies that that data is text (for databases), so when you have some text that has simple quotes, you need to add the escape that is a single quote more.

Example:

--Nesse caso irá ocorrer o erro
INSERT INTO TABELA (ID, NOME) VALUES (1, 'Caixa d'água');

--Nesse caso irá funcionar
INSERT INTO TABELA (ID, NOME) VALUES (1, 'Caixa d''água');

A possible solution is for you to add an extra single quote or remove the single quote before sending it to your repository.

Add single quotes

// Vamos supor que esse seja seu campo de texto
var texto = "caixa d'água";

// Iremos substituir as aspas simples adicionando uma aspas a mais
texto = texto.replace(/'/g, "''");

// O resultado será "caixa d''água"

Remove single quotes

// Vamos supor que esse seja seu campo de texto
var texto = "caixa d'água";

// Iremos remover as aspas simples do nosso campo
texto = texto.replace(/'/g, "");

// O resultado será "caixa dágua"