"ORA-01756: quoted string not properly terminated"

Question

"ORA-01756: quoted string not properly terminated"

Navigation

#1 by (3 votes)

2

Talk to people, good morning, I have a legacy code and I'm having the following difficulty:

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

Ex: raphael me'lo

Now when I try:

Ex: raphael me''lo

I do not get that error, but I can not figure out where he's doing this check:

follow the line of code:

undue-words.model.js :

'use strict';

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

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

undue-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;

undue-words.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'm grateful right away.

javascript oracle node.js

asked by anonymous 02.01.2019 / 13:09

1 answer

String was not recognized as a valid DateTime How to measure temporal complexity of sorting algorithms?

score 3 · Accepted Answer

The content in single quotation marks identifies that data as text (for databases), so when you have text that has single quotation marks, you need to add the escape that is a single quotation mark.

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');

One possible solution is to add a single quote or remove the single quotes before sending them 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"