SnowConvert: Auxiliares de conversão Oracle PL/SQL

Auxiliar de operador Between

Nota

Talvez você também se interesse por Transformação do operador Between

Definição da função de auxiliar do operador Between

 var BetweenFunc = function (expression,startExpr,endExpr) {
   if ([expression,startExpr,endExpr].some((arg) => arg == null)) {
      return null;
   }
   return expression >= startExpr && expression <= endExpr;
};
Copy

Auxiliar de valor Concat

Nota

Esse auxiliar também usa o auxiliar IS NULL

Definição da função de auxiliar Concat

Método auxiliar usado para concatenar valores em um literal de modelo JavaScript. Isso é necessário para verificar se os valores são nulos ou não. O Oracle trata os valores nulos como cadeias de caracteres vazias em concatenações.

 var concatValue = (arg) => IS_NULL(arg) ? "" : arg;
Copy

Auxiliar Cursor

Nota

Você também pode estar interessado em:

Nota

Esse auxiliar também usa o auxiliar Raise e o auxiliar EXEC.

Definição da função auxiliar do cursor

 var FETCH_INTO_COLLECTIONS = function (collections,fetchValues) {
   for(let i = 0;i < collections.length;i++) {
      collections[i].push(fetchValues[i]);
   }
};   
var CURSOR = function (stmt,binds,isRefCursor,isOut) {
   var statementObj, result_set, total_rows, ISOPEN = false, result_set_table = '', self = this, row_count, found;
   this.CURRENT = new Object;
   this.INTO = function () {
         return self.res;
      };
   this.OPEN = function (openParameters) {
         if (ISOPEN && !isRefCursor) RAISE(-6511,"CURSOR_ALREADY_OPEN","cursor already open");
         var finalStmt = openParameters && openParameters.query || stmt;
         var parameters = openParameters && openParameters.binds || [];
         var finalBinds = binds instanceof Function ? binds(...parameters) : binds;
         finalBinds = finalBinds || parameters;
         try {
            if (isOut) {
               if (!temptable_prefix) {
                  temptable_prefix = `${procname}_TEMP_${(EXEC(`select current_session() || '_' || to_varchar(current_timestamp, 'yyyymmddhh24missss')`,{
                        sql : 0
                     }))[0]}_`;
               }
               if (!result_set_table) {
                  result_set_table = temptable_prefix + outCursorResultNumber++;
                  EXEC(`CREATE OR REPLACE TEMPORARY TABLE ${result_set_table} AS ${finalStmt}`,{
                     sql : 0
                  });
               }
               finalStmt = "SELECT * FROM " + result_set_table
            }
            [result_set,statementObj,total_rows] = [EXEC(finalStmt,finalBinds,{
                  sql : 0,
                  row : 2
               }),_RS,_RS.getColumnCount()]
            ISOPEN = true;
            row_count = 0;
         } catch(error) {
            RAISE(error.code,"error",error.message);
         }
         return this;
      };
   this.NEXT = function () {
         if (total_rows && result_set.next()) {
            this.CURRENT = new Object;
            for(let i = 1;i <= statementObj.getColumnCount();i++) {
               (this.CURRENT)[statementObj.getColumnName(i)] = result_set.getColumnValue(i);
            }
            return true;
         } else return false;
      };
   this.FETCH = function (record) {
         var recordKeys = record ? Object.keys(record) : undefined;
         self.res = [];
         if (!ISOPEN) RAISE(-1001,"INVALID_CURSOR","invalid cursor");
         if (recordKeys && recordKeys.length != statementObj.getColumnCount()) RAISE(-6504,"ROWTYPE_MISMATCH","Return types of Result Set variables or query do not match");
         self.res = fetch(statementObj,result_set);
         if (self.res && self.res.length > 0) {
            found = true;
            row_count++;
            if (recordKeys) {
               for(let i = 0;i < self.res.length;i++) {
                  record[recordKeys[i]] = (self.res)[i];
               }
               return false;
            }
            return true;
         } else found = false;
         return false;
      };
   this.CLOSE = function () {
         if (!ISOPEN) RAISE(-1001,"INVALID_CURSOR","invalid cursor");
         found = row_count = result_set_table = total_rows = result_set = statementObj = undefined;
         ISOPEN = false;
      };
   this.FETCH_BULK_COLLECT_INTO = function (variables,limit) {
         if (variables.length != statementObj.getColumnCount()) RAISE(-6504,"ROWTYPE_MISMATCH","Return types of Result Set variables or query do not match");
         if (limit) {
            for(let i = 0;i < limit && this.FETCH();i++)FETCH_INTO_COLLECTIONS(variables,self.res);
         } else {
            while ( this.FETCH() )
               FETCH_INTO_COLLECTIONS(variables,self.res);
         }
      };
   this.FOUND = () => ISOPEN ? typeof(found) == "boolean" ? found : null : RAISE(-1001,"INVALID_CURSOR","invalid cursor");
   this.NOTFOUND = () => ISOPEN ? typeof(found) == "boolean" ? !found : null : RAISE(-1001,"INVALID_CURSOR","invalid cursor");
   this.ROWCOUNT = () => ISOPEN ? row_count : RAISE(-1001,"INVALID_CURSOR","invalid cursor");
   this.ISOPEN = () => ISOPEN;
   this.SAVE_STATE = function () {
         return {
            tempTable : result_set_table,
            position : row_count
         };
      };
   this.RESTORE_STATE = function (tempTable,position) {
         result_set_table = tempTable
         if (result_set_table) {
            isOut = true
            this.OPEN();
            for(let i = 0;i < position;i++)this.FETCH();
         }
      };
   this.ROWTYPE = () => ROWTYPE(stmt,binds());
};
var outCursorResultNumber = 0;
Copy

Auxiliar EXEC

Nota

Você também pode estar interessado em:

Nota

O auxiliar EXEC depende do auxiliar IS NULL.

Sintaxe

EXEC(stmt)
EXEC(stmt, binds[])
EXEC(stmt, opts{})
EXEC(stmt, binds[], opts{})

Parâmetros

stmt

A cadeia de caracteres da instrução SQL a ser executada.

binds (opcional)

Uma matriz com os valores ou as variáveis a serem vinculadas à instrução SQL.

opts (opcional)

Esse é um objeto Javascript para descrever como os valores retornados pelo exec devem ser formatados, usado para instruções SELECT.

Argumentos válidos para o parâmetro opts

As tabelas a seguir descrevem como os argumentos devem ser enviados ao parâmetro opts na chamada EXEC:

Opções quando uma consulta retorna uma única linha

opts

description

{ }

Quando opts estiver vazio ou não for enviado para a chamada de execução, os dados serão retornados em uma matriz.

{vars: 0}

Isso tem o mesmo efeito que a opção padrão. Ele retornará os dados em uma matriz.

{vars: 1}

Isso é usado quando uma consulta retorna apenas uma coluna e uma linha. EXEC retornará o valor diretamente. Isso é equivalente a EXEC(stmt)[0]

{rec:recordVariable}

Usado quando você deseja armazenar os valores retornados pela consulta dentro de um registro. A conversão de registros é descrita em Referência de conversão de registros. A variável de registro deve ser passada como argumento.

{row: 1}

Essa opção retorna uma cópia de ResultSet, o que significa que o objeto retornado contém os métodos descritos na documentação do Snowflake para ResultSet.

Opções quando uma consulta retorna várias linhas

opts

Descrição

{row:2}

Com essa opção, ele sempre retorna uma cópia de ResultSet independentemente do número de linhas retornadas por EXEC.

Opções gerais

opts

Descrição

{sql:0}

Ele garante que o atributo de cursor implícito SQL não seja modificado após a execução da instrução.

Definição da função de auxiliar EXEC

 var formatDate = (arg) => (new Date(arg - (arg.getTimezoneOffset() * 60000))).toISOString().slice(0,-1);
var fixBind = function (arg) {
   arg = arg instanceof Date ? formatDate(arg) : IS_NULL(arg) ? null : arg;
   return arg;
};
var _RS, _ROWS, SQLERRM = "normal, successful completion", SQLCODE = 0;
var getObj = (_rs) => Object.assign(new Object(),_rs);
var getRow = (_rs) => (values = Object.values(_rs)) && (values = values.splice(-1 * _rs.getColumnCount())) && values;
var fetch = (_RS,_ROWS,fmode) => _RS.getRowCount() && _ROWS.next() && (fmode ? getObj : getRow)(_ROWS) || (fmode ? new Object() : []);

var EXEC = function (stmt,binds,opts) {
   try {
      binds = !(arguments[1] instanceof Array) && ((opts = arguments[1]) && []) || (binds || []);
      opts = opts || new Object();
      binds = binds ? binds.map(fixBind) : binds;
      _RS = snowflake.createStatement({
            sqlText : stmt,
            binds : binds
         });
      _ROWS = _RS.execute();
      if (opts.sql !== 0) {
         var isSelect = stmt.toUpperCase().trimStart().startsWith("SELECT");
         var affectedRows = isSelect ? _RS.getRowCount() : _RS.getNumRowsAffected();
         SQL.FOUND = affectedRows != 0;
         SQL.NOTFOUND = affectedRows == 0;
         SQL.ROWCOUNT = affectedRows;
      }
      if (opts.row === 2) {
         return _ROWS;
      }
      var INTO = function (opts) {
         if (opts.vars == 1 && _RS.getColumnCount() == 1 && _ROWS.next()) {
            return _ROWS.getColumnValue(1);
         }
         if (opts.rec instanceof Object && _ROWS.next()) {
            var recordKeys = Object.keys(opts.rec);
            Object.assign(opts.rec,Object.fromEntries(new Map(getRow(_ROWS).map((element,Index) => [recordKeys[Index],element]))))
            return opts.rec;
         }
         return fetch(_RS,_ROWS,opts.row);
      };
      var BULK_INTO_COLLECTION = function (into) {
         for(let i = 0;i < _RS.getRowCount();i++) {
            FETCH_INTO_COLLECTIONS(into,fetch(_RS,_ROWS,opts.row));
         }
         return into;
      };
      if (_ROWS.getRowCount() > 0) {
         return _ROWS.getRowCount() == 1 ? INTO(opts) : BULK_INTO_COLLECTION(opts);
      }
   } catch(error) {
      RAISE(error.code,error.name,error.message)
   }
};
Copy

Amostras de uso

Nota

Para todas as amostras, o código de auxiliares do SnowConvert foi removido.

Os exemplos de código a seguir ilustram o funcionamento de EXEC.

Caso simples de EXEC

Oracle

 --Additional Params: -t JavaScript
CREATE OR REPLACE PROCEDURE EXECUTE_PROC AS
BEGIN
  --CREATES HARDWARE TABLE WITH COLUMNS ID, DEVICE AND COLOR
  --THIS IS AN EXECUTE IMMEDIATE JUST WITH AN STATEMENT
  EXECUTE IMMEDIATE 'CREATE TABLE HARDWARE (ID NUMBER, DEVICE VARCHAR2(15), COLOR VARCHAR(15))';
END;
Copy

Snowflake

 CREATE OR REPLACE PROCEDURE EXECUTE_PROC ()
RETURNS STRING
LANGUAGE JAVASCRIPT
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"oracle"}}'
EXECUTE AS CALLER
AS
$$
  // SnowConvert Helpers Code section is omitted.

  //CREATES HARDWARE TABLE WITH COLUMNS ID, DEVICE AND COLOR
  //THIS IS AN EXECUTE IMMEDIATE JUST WITH AN STATEMENT
  EXEC(`CREATE OR REPLACE TABLE HARDWARE (ID NUMBER(38, 18),
   DEVICE VARCHAR(15),
   COLOR VARCHAR(15))`);
$$;
Copy

EXEC com vínculos

Oracle

 --Additional Params: -t JavaScript
CREATE OR REPLACE PROCEDURE EXECUTE_PROC AS 
  ID_VAR NUMBER;
  DEVICE_VAR VARCHAR2(15);
  DEV_COLOR  VARCHAR2(15);
  COLOR_VAR  VARCHAR2(15);
BEGIN
  --EXEC WITH BINDINGS
  --INSERTS A ROW WITH  | 12 | MOUSE | BLACK |  VALUES USING DIRECT BINDING FOR MOUSE
  EXECUTE IMMEDIATE 'INSERT INTO HARDWARE VALUES (12, :MOUSE, ''BLACK'')' USING 'MOUSE';

  --INSERTS A ROW WITH  | 13 | KEYBOARD | WHITE |  VALUES USING DIRECT BINDING FOR 13 AND KEYBOARD
  EXECUTE IMMEDIATE 'INSERT INTO HARDWARE VALUES (:ID, :KEYBOARD, ''WHITE'')' USING 13, 'KEYBOARD';
  
  --INSERTS A ROW WITH  | 14 | HEADSET | GRAY |  VALUES USING BINDING VARIABLES
  ID_VAR := 14;
  DEVICE_VAR := 'HEADSET';
  COLOR_VAR := 'GRAY';
  EXECUTE IMMEDIATE 'INSERT INTO HARDWARE VALUES (:DEV_ID, :DEV_VAR, :DEV_COLOR)' USING  ID_VAR, DEVICE_VAR, COLOR_VAR;
END;
Copy

Snowflake

 CREATE OR REPLACE PROCEDURE EXECUTE_PROC ()
RETURNS STRING
LANGUAGE JAVASCRIPT
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"oracle"}}'
EXECUTE AS CALLER
AS
$$
  // SnowConvert Helpers Code section is omitted.
  
  let ID_VAR;
  let DEVICE_VAR;
  let DEV_COLOR;
  let COLOR_VAR;
  //EXEC WITH BINDINGS
  //INSERTS A ROW WITH  | 12 | MOUSE | BLACK |  VALUES USING DIRECT BINDING FOR MOUSE
  EXEC(`INSERT INTO HARDWARE
VALUES (12, ?, 'BLACK')`,[`MOUSE`]);
  //INSERTS A ROW WITH  | 13 | KEYBOARD | WHITE |  VALUES USING DIRECT BINDING FOR 13 AND KEYBOARD
  EXEC(`INSERT INTO HARDWARE
VALUES (?, ?, 'WHITE')`,[13,`KEYBOARD`]);

  //INSERTS A ROW WITH  | 14 | HEADSET | GRAY |  VALUES USING BINDING VARIABLES
  ID_VAR = 14;
  DEVICE_VAR = `HEADSET`;
  COLOR_VAR = `GRAY`;
  EXEC(`INSERT INTO HARDWARE
VALUES (?, ?, ?)`,[ID_VAR,DEVICE_VAR,COLOR_VAR]);
$$;
Copy

EXEC com opções

Oracle

 --Additional Params: -t JavaScript
CREATE OR REPLACE PROCEDURE EXECUTE_PROC AS   
BEGIN
  --STORES THE ID INTO ID_VAR
  EXECUTE IMMEDIATE 'SELECT ID FROM HARDWARE WHERE COLOR = ''BLACK''' INTO ID_VAR;
  DBMS_OUTPUT.PUT_LINE(ID_VAR);
  
  --STORES THE ID AND DEVICE INTO ID_VAR AND DEV_VAR, USING BINDING FOR COLOR
  COLOR_VAR := 'BLACK';
  EXECUTE IMMEDIATE 'SELECT ID, DEVICE FROM HARDWARE WHERE COLOR = :DEV_COLOR' INTO ID_VAR, DEVICE_VAR USING COLOR_VAR;
  DBMS_OUTPUT.PUT_LINE(ID_VAR || ' ' || DEVICE_VAR);
END;
Copy

Snowflake

 CREATE OR REPLACE PROCEDURE EXECUTE_PROC ()
RETURNS STRING
LANGUAGE JAVASCRIPT
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"oracle"}}'
EXECUTE AS CALLER
AS
$$
  // SnowConvert Helpers Code section is omitted.

  //STORES THE ID INTO ID_VAR
  [ID_VAR] = EXEC(`SELECT ID FROM
   HARDWARE
WHERE COLOR = 'BLACK'`);
  EXEC(`--** SSC-FDM-OR0035 - CHECK UDF IMPLEMENTATION FOR DBMS_OUTPUT.PUT_LINE_UDF. **
CALL DBMS_OUTPUT.PUT_LINE_UDF(ID_VAR)`);

  //STORES THE ID AND DEVICE INTO ID_VAR AND DEV_VAR, USING BINDING FOR COLOR
  COLOR_VAR = `BLACK`;
  [ID_VAR,DEVICE_VAR] = EXEC(`SELECT ID, DEVICE FROM
   HARDWARE
WHERE COLOR = ?`,[
    !!!RESOLVE EWI!!! /*** SSC-EWI-0053 - OBJECT COLOR_VAR MAY NOT WORK PROPERLY, ITS DATATYPE WAS NOT RECOGNIZED ***/!!!
    COLOR_VAR]);
  EXEC(`--** SSC-FDM-OR0035 - CHECK UDF IMPLEMENTATION FOR DBMS_OUTPUT.PUT_LINE_UDF. **
CALL DBMS_OUTPUT.PUT_LINE_UDF(NVL(ID_VAR :: STRING, '') || ' ' || NVL(DEVICE_VAR :: STRING, ''))`);
$$;
Copy

Na amostra a seguir, a chamada EXEC retorna [12], com a desestruturação do objeto ID_VAR armazena 12:

 [ID_VAR] = EXEC(`SELECT ID FROM PUBLIC.HARDWARE WHERE COLOR = 'BLACK'`);
Copy

As duas chamadas EXEC a seguir são formas alternativas para o exemplo anterior sem desestruturação de objeto:

 ID_VAR = EXEC(`SELECT ID FROM PUBLIC.HARDWARE WHERE COLOR = 'BLACK'`)[0];
ID_VAR = EXEC(`SELECT ID FROM PUBLIC.HARDWARE WHERE COLOR = 'BLACK'`, {vars:1});
Copy

A desestruturação de objetos também funciona com vinculações, como você pode observar nessas instruções («EXEC call returns [12, «MOUSE»] values»):

 COLOR_VAR = `BLACK`;
[ID_VAR,DEVICE_VAR] = EXEC(`SELECT ID, DEVICE FROM PUBLIC.HARDWARE WHERE COLOR = ?`,[COLOR_VAR]);
Copy

Para obter o conjunto de resultados reais retornados pelo Snowflake, você pode usar esta sintaxe:

 let RESULT_SET_COPY;
RESULT_SET_COPY = EXEC(`SELECT * FROM PUBLIC.HARDWARE WHERE COLOR = 'BLACK'`, {row:1});
/* RETURNS
{
  "COLOR": "BLACK",
  "DEVICE": "MOUSE",
  "ID": 12,
  "getColumnCount": {},
  ...
  "next": {}
}*/
Copy

EXEC com tipos de registro

Nota

Você pode estar interessado em Transformação de registros.

Oracle

 --Additional Params: -t JavaScript

CREATE OR REPLACE PROCEDURE EXECUTE_PROC AS  
  TYPE DEVTRECTYP IS RECORD (
    ID NUMBER(4) NOT NULL := 0,
    DEV_TYPE VARCHAR2(30) NOT NULL := 'UNKNOWN',
    COLOR VARCHAR2(30) := 'GREEN'
  );

  DEV_VARIABLE DEVTRECTYP; 
BEGIN

  --STORES THE ROW VALUES IN THE RECORD
  EXECUTE IMMEDIATE 'SELECT * FROM HARDWARE WHERE COLOR = ''BLACK''' INTO DEV_VARIABLE;
  DBMS_OUTPUT.PUT_LINE(DEV_VARIABLE.ID || ' ' || DEV_VARIABLE.DEV_TYPE || ' ' || DEV_VARIABLE.COLOR);
END;
Copy

Snowflake

 CREATE OR REPLACE PROCEDURE EXECUTE_PROC ()
RETURNS STRING
LANGUAGE JAVASCRIPT
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},"attributes":{"component":"oracle"}}'
EXECUTE AS CALLER
AS
$$
  // SnowConvert Helpers Code section is omitted.

  class DEVTRECTYP {
    ID = 0
    DEV_TYPE = `UNKNOWN`
    COLOR = `GREEN`
    constructor() {
      [...arguments].map((element,Index) => this[(Object.keys(this))[Index]] = element)
    }
  }
  let DEV_VARIABLE = new DEVTRECTYP();
  //STORES THE ROW VALUES IN THE RECORD
  EXEC(`SELECT * FROM
   HARDWARE
WHERE COLOR = 'BLACK'`,{
    rec : DEV_VARIABLE
  });
  EXEC(`--** SSC-FDM-OR0035 - CHECK UDF IMPLEMENTATION FOR DBMS_OUTPUT.PUT_LINE_UDF. **
CALL DBMS_OUTPUT.PUT_LINE_UDF(NVL(? :: STRING, '') || ' ' || NVL(? :: STRING, '') || ' ' || NVL(? :: STRING, ''))`,[DEV_VARIABLE.ID,DEV_VARIABLE.DEV_TYPE,DEV_VARIABLE.COLOR]);
$$;
Copy

Aviso

Esse ainda é um trabalho em andamento. A transformação para armazenar adequadamente os valores de registro será:

 EXEC(`SELECT * FROM PUBLIC.HARDWARE WHERE COLOR = 'BLACK'`, {rec:DEV_VARIABLE});
Copy

Problemas conhecidos

Não foram encontrados problemas.

Auxiliar de atributo do Cursor implícito

Visão geral

Esses são os atributos que você pode usar dentro dos procedimentos armazenados do Snowflake usando esse auxiliar:

  • FOUND

  • NOTFOUND

  • ROWCOUNT

  • ISOPEN

No código do Snowflake, dentro dos procedimentos, você encontrará a inicialização desses atributos:

  var SQL = {
  FOUND : false,
  NOTFOUND : false,
  ROWCOUNT : 0,
  ISOPEN : false
 };
Copy

Os valores dos atributos: FOUND, NOTFOUND, ROWCOUNT são atualizados dentro do auxiliar EXEC..

O atributo ISOPEN é sempre falso, assim como no Oracle.

Amostras de uso

Entrada

 --Additional Params: -t JavaScript

CREATE OR REPLACE PROCEDURE PROC1
IS
VAR1 VARCHAR(100) := '';
BEGIN
    SELECT COL1 INTO VAR1 FROM TABLE1 WHERE COL1 = 1;
    VAR1 := 'Rows affected: ' || TO_CHAR(SQL%ROWCOUNT);
    VAR1 := 'Error: ' || SQLERRM;

    PKG.TEST_PROC1(SQL%ROWCOUNT, SQL%FOUND, SQL%NOTFOUND);
    PKG.TEST_PROC2(SQLCODE);

    SELECT SQL%ROWCOUNT FROM DUAL;
END;
Copy

Saída

 CREATE OR REPLACE PROCEDURE PROC1 ()
RETURNS STRING
LANGUAGE JAVASCRIPT
COMMENT = '{"origin":"sf_sc","name":"snowconvert","version":{"major":1, "minor":0},{"attributes":{"component":"oracle"}}'
EXECUTE AS CALLER
AS
$$
    // SnowConvert Helpers Code section is omitted.

    let VAR1 = undefined;
    [VAR1] = EXEC(`SELECT
   COL1
FROM
   TABLE1
WHERE COL1 = 1`);
    VAR1 = `Rows affected: ${concatValue((EXEC(`SELECT
   TO_CHAR(?)`,[SQL.ROWCOUNT]))[0])}`;
    VAR1 = `Error: ${concatValue(SQLERRM)}`;
    EXEC(`CALL

PKG.TEST_PROC1(?, ?, ?)`,[SQL.ROWCOUNT,SQL.FOUND,SQL.NOTFOUND]);
    EXEC(`CALL
PKG.TEST_PROC2(?)`,[SQLCODE]);
    EXEC(`SELECT
       ?
    FROM DUAL`,[SQL.ROWCOUNT]);
$$;
Copy

Nota

SQLCODE e SQLERRM são convertidos em variáveis auxiliares com o mesmo nome e são vinculados da mesma forma que as variáveis do cursor.

Problemas conhecidos

Não foram encontrados problemas.

EWIs Relacionados

Sem EWIs relacionados.

Auxiliar IS NULL

Nota

Você também pode se interessar pela transformação IS [NOT] NULL.

Definição da função de auxiliar IS NULL

Esse método auxiliar é usado para transformar o predicado NULL. Ele também é usado por outros auxiliares para verificar se um valor é nulo. Isso é necessário para tratar valores como NaN ou cadeias de caracteres vazias como nulos.

O Oracle trata as cadeias de caracteres vazias como valores nulos. Esse auxiliar leva isso em consideração.

 var IS_NULL = (arg) => !(arg || arg === 0);
Copy

Auxiliar do operador Like

Nota

Talvez você também se interesse pela transformação do operador Like

Definição da função de auxiliar do operador Like

 function LIKE(expr,pattern,esc,cs) {
   function fixPattern(pattern,esc) {
      const specials = '/.*+?|(){}[]\\'.split('');
      var newPattern = "";
      var fix = (c) => specials.includes(c) ? '\\' + c : c;
      for(var i = 0;i < pattern.length;i++) {
         var c = pattern[i];
         if (c === esc) {
            newPattern += pattern[i + 1]
            i++
         } else if (c === '%') {
            newPattern += ".*?"
         } else if (c === '_') {
            newPattern += "."
         } else if (c === '[' || ']') {
            newPattern += c
         } else newPattern += fix(c)
      }
      return newPattern;
   }
   return new RegExp(`^${fixPattern(pattern,esc)}$`,cs ? '' : 'i').exec(expr) != null;
}
Copy

Auxiliar de variáveis de pacote

Nota

Talvez você também se interesse pela declaração de variáveis e variáveis de pacote dentro de procedimentos.

Definição da função de auxiliar de variáveis de pacote

Nota

O auxiliar depende do auxiliar IS NULL.

Quando uma variável de pacote é usada dentro de um procedimento, o seguinte auxiliar será gerado:

Quando uma variável de pacote é usada dentro de um procedimento, o seguinte auxiliar será gerado:

 function StateManager(packageName,keepInCache) {
   function getTypeChar(arg) {
      if (arg instanceof Date) {
         return "&";
      } else if (typeof arg == "number") {
         return "#";
      } else if (IS_NULL(arg)) {
         return "~";
      } else {
         return "$";
      }
   }
   function deserialize(arg) {
      if (arg === null) return undefined;
      let prefix = arg[0];
      let rest = arg.substr(1);
      switch(prefix) {
         case "&":return new Date(rest);
         case "#":return parseFloat(rest);
         case "$":return rest;
         case "~":return undefined;
         default:return arg;
      }
   }
   function saveVar(varName,value) {
      let varPackageName = `${packageName}.${varName}`;
      let fixedValue = `${getTypeChar(value)}${fixBind(value)}`;
      EXEC("SELECT SETVARIABLE(?,?)",[varPackageName,fixedValue]);
   }
   function readVar(varName) {
      let varPackageName = `${packageName}.${varName}`;
      return deserialize((EXEC("SELECT GETVARIABLE(?)",[varPackageName]))[0]);
   }
   this.saveState = function () {
         let keys = Object.keys(this.cache);
         for(let key of keys) {
            saveVar(key,(this.cache)[key]);
         }
      }
   this.cache = new Object();
   let c = this.cache;
   let rsProxy = new Proxy(this,{
      get : function (target,prop,receiver) {
         if (!target[prop]) {
            c[prop] === undefined && (c[prop] = readVar(prop));
            return c[prop];
         }
         return Reflect.get(...arguments);
      },
      set : function (target,prop,value) {
         if (target[prop]) return;
         c[prop] = value;
         if (!keepInCache) {
            saveVar(prop,value);
         }
      }
   });
   return rsProxy;
};
var PACKAGE_VARIABLES = new StateManager("PACKAGE_VARIABLES",true);
Copy

Uma instância de auxiliar é criada para cada pacote usado para acessar suas variáveis. As variáveis serão qualificadas com o nome do pacote se não forem qualificadas com ele.

No final do procedimento, o estado das variáveis usadas será salvo usando o auxiliar.

Observe que, na instrução a seguir, o nome da variável será alterado para corresponder ao nome do pacote:

 var PACKAGE_VARIABLES = new StateManager("PACKAGE_VARIABLES",true);
Copy

Auxiliar Raise

Nota

Talvez você tenha interesse no tratamento de erros e exceções

Definição da função de auxiliar Raise

 var RAISE = function (code,name,message) {
    message === undefined && ([name,message] = [message,name])
    var error = new Error(message);
    error.name = name
    SQLERRM = `${(SQLCODE = (error.code = code))}: ${message}`
    throw error;
};
Copy

Auxiliar ROWTYPE

Nota

Você pode estar interessado em declaração de registro ROWTYPE

Definição da função de auxiliar ROWTYPE

 var ROWTYPE = (stmt, binds = [], obj = new Object()) => {
      EXEC(`SELECT * FROM (${stmt}) LIMIT 0`,binds);
      for(let i = 1;i <= _RS.getColumnCount();i++)obj[_ROWS.getColumnName(i)] = null;
      return obj;
   };
Copy