Grunderna i Neo4j-grafdatabaser · Lektion

Lagrade procedurer och UDF:er

Lär er skriva och distribuera anpassade lagrade procedurer och användardefinierade funktioner för att kapsla in komplex logik och utöka Cypher.

Lektion 1 av 411 steg

Lagrade procedurer och UDF:er är en gratis lektion i Grunderna i Neo4j-grafdatabaser på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Grunderna i Neo4j-grafdatabaser, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Grunderna i Neo4j-grafdatabaser innehåller totalt 4 lektioner.

Utöka Neo4j:s funktioner

Välkomna till avsnittet om att utöka Neo4j! Ibland räcker Cypher inte till för komplex logik eller specifika integrationer. Då kommer anpassad kod in i bilden.

Neo4j gör det möjligt att utöka funktionaliteten med lagrade procedurer och användardefinierade funktioner (UDF:er), som vanligtvis skrivs i Java.

Lag rade procedurer utför åtgärder, till exempel att skapa noder eller köra komplexa algoritmer.
Användardefinierade funktioner (UDF:er) returnerar värden, precis som inbyggda Cypher-funktioner.

De kapslar in komplex logik, förbättrar frågornas läsbarhet och ökar prestandan för återkommande uppgifter.

Procedurer kontra användardefinierade funktioner

Det är viktigt att förstå skillnaden mellan procedurer och UDF:er:

Lagrade procedurer:
- Anropas med CALL package.procedure()
- Kan orsaka sidoeffekter (skapa, uppdatera och ta bort data)
- Returnerar tabellresultat (rader och kolumner)
- Kan komma åt grafdatabasen direkt
Användardefinierade funktioner (UDF:er):
- Anropas i Cypher-uttryck (t.ex. RETURN my.udf(n.property))
- Måste vara rena funktioner (utan sidoeffekter)
- Returnerar ett enda skalärt värde (t.ex. sträng, tal, booleskt värde eller lista)
- Kan inte ändra grafen eller komma åt den direkt

En lagrad procedurs uppbyggnad (Java)

Lagrade procedurer är Java-klasser som kompileras till en JAR-fil. De använder särskilda Neo4j-annoteringar.

Här är grundstrukturen för en enkel procedur som inte tar några parametrar och returnerar en sträng:

package com.coddykit;

import org.neo4j.procedure.Procedure;
import org.neo4j.procedure.Name;
import org.neo4j.procedure.Description;
import org.neo4j.graphdb.Result;
import java.util.stream.Stream;

public class MyProcedures {

    // Define the output record structure
    public static class StringOutput {
        public String value;

        public StringOutput(String value) {
            this.value = value;
        }
    }

    @Procedure(value = "my.hello")
    @Description("Returns a simple greeting.")
    public Stream<StringOutput> hello() {
        return Stream.of(new StringOutput("Hello from CoddyKit!"));
    }
}

Viktiga delar i en procedur

Vi går igenom den föregående koden:

@Procedure(value = "my.hello"): Den här annoteringen deklarerar en metod som en lagrad procedur och anger dess fullständiga namn (my.hello).
@Description: Tillhandahåller en beskrivning som visas i Neo4j Browser.
Utdataklass (StringOutput): Procedurer returnerar en Stream med anpassade objekt. Varje objekt representerar en rad i resultatet och dess publika fält blir kolumnnamnen.
Stream<StringOutput>: Returtypen för procedurer.

Den här Java-koden är redo att kompileras till en JAR-fil och distribueras.

Distribuera den anpassade proceduren

För att göra Java-proceduren tillgänglig i Neo4j måste ni kompilera den och placera den resulterande JAR-filen i databasens katalog plugins.

Steg:

Kompilera Java-koden till en JAR-fil, till exempel my-procedures.jar.
Kopiera JAR-filen till mappen plugins i Neo4j-installationen.
Starta om Neo4j-databasinstansen.

Efter omstarten kommer Neo4j att upptäcka och registrera de nya procedurerna och funktionerna.

Anropa en lagrad procedur

När proceduren har distribuerats kan ni anropa den med nyckelordet CALL i Cypher. Vi provar att anropa proceduren my.hello:

CALL my.hello();

En användardefinierad funktions uppbyggnad (UDF)

UDF:er liknar procedurer men har andra annoteringar och returtyper. De är utformade för att användas direkt i Cypher-uttryck.

Här är grundstrukturen för en UDF som tar en sträng och returnerar en modifierad sträng:

package com.coddykit;

import org.neo4j.procedure.UserFunction;
import org.neo4j.procedure.Name;
import org.neo4j.procedure.Description;

public class MyFunctions {

    @UserFunction("my.capitalize")
    @Description("Capitalizes the first letter of an input string.")
    public String capitalize(@Name("input") String input) {
        if (input == null || input.isEmpty()) {
            return input;
        }
        return Character.toUpperCase(input.charAt(0)) + input.substring(1);
    }
}

Viktiga delar i en UDF

Vi går igenom UDF:ens komponenter:

@UserFunction("my.capitalize"): Den här annoteringen deklarerar en metod som en UDF och definierar dess fullständiga namn (my.capitalize).
@Name("input"): Anger namnet på parametern när den används i Cypher.
Returtyp: UDF:er returnerar ett enda skalärt värde (t.ex. String, Long, Boolean, List<String>). De returnerar inte en Stream eller anpassade resultatobjekt.

Precis som procedurer måste denna Java-kod kompileras till en JAR-fil och distribueras till mappen plugins.

Anropa en användardefinierad funktion

När UDF:en har distribuerats kan ni använda den direkt i Cypher-frågor som en del av ett uttryck. Den fungerar precis som inbyggda funktioner.

Vi använder vår UDF my.capitalize:

RETURN my.capitalize("hello world");

// Or with graph data:
MATCH (p:Person)
RETURN p.name, my.capitalize(p.name) AS CapitalizedName;

Snabbkontroll: procedurer och UDF:er

Vilket av följande påståenden är SANT om Neo4j Stored Procedures och User-Defined Functions (UDF:er)?

Besvara frågan i den interaktiva lektionen

Sammanfattning och nästa steg

Ni har lärt er att utöka Neo4j med anpassad Java-kod!

Stored Procedures utför komplexa åtgärder, returnerar tabellresultat och anropas med CALL.
User-Defined Functions (UDF:er) returnerar ett enda skalärt värde, är rena funktioner (utan sidoeffekter) och används direkt i Cypher-uttryck.
Båda kräver Java-kod, specifika Neo4j-annoteringar, kompilering till en JAR-fil och distribution till Neo4j-katalogen plugins.

Dessa kraftfulla tillägg gör det möjligt att integrera anpassad logik, algoritmer och externa tjänster direkt i er Neo4j-miljö, vilket utökar dess funktioner avsevärt.

Gratis att börja

Lär dig Grunderna i Neo4j-grafdatabaser med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Lagrade procedurer och UDF:er” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Grunderna i Neo4j-grafdatabaser, inklusive ”Lagrade procedurer och UDF:er”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Grunderna i Neo4j-grafdatabaser innehåller totalt 4 lektioner.

Vad lär jag mig i ”Lagrade procedurer och UDF:er”?

Lär er skriva och distribuera anpassade lagrade procedurer och användardefinierade funktioner för att kapsla in komplex logik och utöka Cypher. Ni övar på Grunderna i Neo4j-grafdatabaser med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Grunderna i Neo4j-grafdatabaser?

Du behöver inga förkunskaper. Utbildningen i Grunderna i Neo4j-grafdatabaser på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Lagrade procedurer och UDF:er”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Grunderna i Neo4j-grafdatabaser-lektionen?

Ja. Varje Grunderna i Neo4j-grafdatabaser-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Lagrade procedurer och UDF:er
Integrera med BI- och visualiseringsverktyg
Avancerade pipelines för dataimport
Fulltextsökning och vektorsökning i Neo4j

← Tillbaka till Grunderna i Neo4j-grafdatabaser