Adresse IP stockées comme séparateur décimal - PL/SQL pour afficher en pointillés quad

Nous avons une base de données Oracle qui contient des adresses IP stockées comme des entiers décimaux - c'est incroyablement douloureux lors de la manipulation des données par les mains plutôt que via l'interface web, mais la main de la manipulation est très pratique et le réseau gars constamment nous demander de faire des choses étranges que l'interface web d'auteurs n'ont pas l'anticiper.

Quelqu'un pourrait-il me fournir le code PL/SQL ou autre méthode pour afficher ces décimales IPs comme décimale c'est à dire 123.123.123.123 format?

I. e. J'aimerais être en mesure d'exécuter une requête telle que :

select hostname, inttoip(ip_address) from host;

et ont la inttoip() procédure d'affichage de l'adresse ip comme 203.30.237.2 au lieu de 3407801602.

Idéalement, j'aimerais une procédure qui fournit la fonction inverse aussi, par exemple,

insert into host (hostname,ip_address) values ('some-hostname', iptoint('203.30.237.2'));

J'ai perl pour ce faire, mais mon PL/SQL/Oracle de connaissances n'est pas suffisant pour un port en PL/SQL.

Sinon un moyen d'exécuter le perl comme la langue de la procédure au sein de l'oracle contexte analogue à celui-ci dans postgres:

CREATE FUNCTION perl_func (integer) RETURNS integer AS $$
 <some perl>
$$ LANGUAGE plperl;

Serait formidable - si possible - peut-être même mieux que je le pouvais alors faire beaucoup de procédure des choses dans Oracle dans une langue que je suis familier avec.

Il est à l'intérieur de la JVM d'Oracle. N'perl version existent qui peuvent s'exécuter à l'intérieur de la JVM? Si oui, vous pouvez utiliser perl. Il est par exemple possible d'exécuter Jython avec l'Oracle de la JVM. Lire ici: forums.oracle.com/forums/...

OriginalL'auteur Jason Tan | 2009-07-05

  1. 6

    C'est la fonction dont vous avez besoin:

    create or replace
function inttoip(ip_address integer) return varchar2
deterministic
is
begin
    return to_char(mod(trunc(ip_address/256/256/256),256))
           ||'.'||to_char(mod(trunc(ip_address/256/256),256))
           ||'.'||to_char(mod(trunc(ip_address/256),256))
           ||'.'||to_char(mod(ip_address,256));
end;

    (Commentaires à propos de la fonction de décision déterministe et à l'aide de to_char pris à bord - grâce).

    Dans Oracle 11G, vous pourriez faire la mise en forme de l'adresse IP virtuelle de la colonne dans la table d'hôtes:

    alter table host
add formatted_ip_address varchar2(15)
generated always as
( to_char(mod(trunc(ip_address/256/256/256),256))
          ||'.'||to_char(mod(trunc(ip_address/256/256),256))
          ||'.'||to_char(mod(trunc(ip_address/256),256))
          ||'.'||to_char(mod(ip_address,256))
) virtual;

    Cette colonne pourrait ensuite être indexé pour les requêtes, si nécessaire.

    Votre requête devient:

    select hostname, formatted_ip_address from host;
    Vous pouvez déclarer la fonction déterministe. Qui rend possible l'utilisation de cette fonction dans une fonction d'index de base (fbi). À l'aide d'un fbi peut résoudre les problèmes de performance.
    Vous pouvez même définir la MOD(.....) comme une colonne dans une vue de dessus de la table de base(s), en évitant le PL/SQL couche. 11g pourrait avoir comme une colonne virtuelle.
    Je serais en utilisant explicite nombre de char de conversion en il ainsi moi-même je pense.

    OriginalL'auteur Tony Andrews

  2. 2
    CREATE OR REPLACE
FUNCTION inttoip(ip_address IN INTEGER) RETURN VARCHAR2 IS
v8 VARCHAR2(8);
BEGIN
-- 1. convert the integer into hexadecimal representation
v8 := TO_CHAR(ip_address, 'FMXXXXXXXX');
-- 2. convert each XX portion back into decimal
RETURN to_number(substr(v8,1,2),'XX')
|| '.' || to_number(substr(v8,3,2),'XX')
|| '.' || to_number(substr(v8,5,2),'XX')
|| '.' || to_number(substr(v8,7,2),'XX');
END inttoip;
CREATE OR REPLACE
FUNCTION iptoint(ip_string IN VARCHAR2) RETURN INTEGER IS
d1 INTEGER;
d2 INTEGER;
d3 INTEGER;
q1 VARCHAR2(3);
q2 VARCHAR2(3);
q3 VARCHAR2(3);
q4 VARCHAR2(3);
v8 VARCHAR2(8);
BEGIN
-- 1. parse the input, e.g. '203.30.237.2'
d1 := INSTR(ip_string,'.');     -- first dot
d2 := INSTR(ip_string,'.',1,2); -- second dot
d3 := INSTR(ip_string,'.',1,3); -- third dot
q1 := SUBSTR(ip_string, 1, d1 - 1);           -- e.g. '203'
q2 := SUBSTR(ip_string, d1 + 1, d2 - d1 - 1); -- e.g. '30'
q3 := SUBSTR(ip_string, d2 + 1, d3 - d2 - 1); -- e.g. '237'
q4 := SUBSTR(ip_string, d3 + 1);              -- e.g. '2'
-- 2. convert to a hexadecimal string
v8 := LPAD(TO_CHAR(TO_NUMBER(q1),'FMXX'),2,'0')
|| LPAD(TO_CHAR(TO_NUMBER(q2),'FMXX'),2,'0')
|| LPAD(TO_CHAR(TO_NUMBER(q3),'FMXX'),2,'0')
|| LPAD(TO_CHAR(TO_NUMBER(q4),'FMXX'),2,'0');
-- 3. convert to a decimal number
RETURN TO_NUMBER(v8, 'FMXXXXXXXX');
END iptoint;

    OriginalL'auteur Jeffrey Kemp

  3. 0
        -- INET ATON en INET NTOA and helper function GET TOKEN
CREATE OR REPLACE function inet_ntoa (ip integer) return varchar2
is
ip1 integer;
ip2 integer;
ip3 integer;
ip4 integer;
ipi integer := ip;
begin
ip1 := floor(ipi/power(2,24));
ipi := ipi - (ip1*power(2,24));
ip2 := floor(ipi/power(2,16));
ipi := ipi - (ip2*power(2,16));
ip3 := floor(ipi/power(2,8));
ipi := ipi - (ip3*power(2,8));
ip4 := ipi;
return ip1||'.'||ip2||'.'||ip3||'.'||ip4;
end;
/    
CREATE OR REPLACE FUNCTION get_token (the_list VARCHAR2,the_index NUMBER, delim VARCHAR2 := '.') RETURN VARCHAR2
IS
start_pos   INTEGER;
end_pos     INTEGER;
BEGIN
IF the_index = 1 THEN
start_pos := 1;
ELSE
start_pos := INSTR (the_list, delim, 1, the_index - 1);
IF start_pos = 0 THEN
RETURN NULL;
ELSE
start_pos := start_pos + LENGTH (delim);
END IF;
END IF;
end_pos := INSTR (the_list, delim, start_pos, 1);
IF end_pos = 0 THEN
RETURN SUBSTR (the_list, start_pos);
ELSE
RETURN SUBSTR (the_list, start_pos, end_pos - start_pos);
END IF;
END get_token;
/
CREATE OR REPLACE function inet_aton (ip varchar2) return integer
is
invalid_ip_adres exception;
pragma exception_init(invalid_ip_adres,-6502);
ipi integer;
begin
ipi := get_token(ip,4)
+(get_token(ip,3)*power(2,8))
+(get_token(ip,2)*power(2,16))
+(get_token(ip,1)*power(2,24));
return ipi;
exception
when invalid_ip_adres
then 
return null;
end;
/
    Je cherchais inet_aton(), et là, je viens de trouver ce post, et votre fonction. Merci beaucoup! P. S. vous devez déclarer inet_* déterministe 🙂
    Votre accueil. Merci pour l'astuce. La fonction ne contenant que les calculs doivent être déclarés comme déterministe.
    Je ne suis pas sûr de ce que tu veux dire par ne contenant que des calculs. "déterministe" dites Oracle que le résultat de la fonction ne changera jamais sur la même entrée. Donc, si je voulais ajouter un index fonctionnel sur tout les inet_* fonctions, ils doivent être déclarés (et ils sont déjà déterministe par la nature).

    OriginalL'auteur Robert Merkwürdigeliebe