Zelfstudie: Operator voor rekenmachine voor samengestelde rente

In deze zelfstudie maakt u een Python UDF-operator voor Lakeflow Designer waarmee samengestelde rente wordt berekend. Gebruik dit voorbeeld om de basisbeginselen te leren van het bouwen van operators die afzonderlijke waarden of kolommen transformeren. Zie Door de gebruiker gedefinieerde operators in Lakeflow Designer voor meer informatie.

Overview

In deze zelfstudie leert u hoe u een door de gebruiker gedefinieerde operator maakt met behulp van een Python UDF. De operator berekent de toekomstige waarde van een investering met behulp van de formule voor samengestelde rente, A = P × (1 + r/n)^(n×t)waarbij:

P = Principal (beginbedrag)
r = Jaarlijks rentepercentage (als decimaal)
n = aantal samengestelde perioden per jaar
t = Tijd in jaren

Requirements

Toegang tot Lakeflow Designer in een werkruimte met Unity Catalog. Zie Voorvereisten.
USE CATALOG op de main catalogus, en CREATE SCHEMA op main, of USE SCHEMA en CREATE FUNCTION op een bestaand main.example_output schema. Om een andere catalogus of schema te gebruiken, vervang main.example_output overal. Raadpleeg Unity Catalog-bevoegdhedenoverzicht.
Compute die Unity Catalog Python UDF's kan draaien. Zie SQL en Python door de gebruiker gedefinieerde functies (UDF's) in Unity Catalog.

Step 1: de functie Python schrijven en testen

Definieer eerst de kernfunctie Python waarmee de berekening wordt uitgevoerd. Test deze in een notebookcel om te controleren of deze correct werkt.

def compound_amount(principal: float,
                    annual_rate: float,
                    compounds_per_year: int,
                    years: float) -> float:
    """
    Compute compound interest future value.

    A = P * (1 + r/n)^(n*t)

    principal: starting amount (P)
    annual_rate: annual nominal rate as decimal (r), e.g. 0.05
    compounds_per_year: compounding periods per year (n), e.g. 12
    years: time in years (t), can be fractional
    """
    import math
    if principal is None or annual_rate is None or compounds_per_year is None or years is None:
        return None

    if compounds_per_year <= 0:
        raise ValueError("compounds_per_year must be > 0")

    return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                 compounds_per_year * years)

Test de functie met een voorbeeldinvestering: $1.000 tegen een jaarlijkse rente van 5%, maandelijks gekapitaliseerd gedurende 10 jaar. Het resultaat zou ongeveer 1647.01moeten zijn.

compound_amount(1000, 0.05, 12, 10)

Stap 2: de YAML voor de operator maken

De YAML-configuratie definieert hoe de operator wordt weergegeven in Lakeflow Designer. Voor deze operator:

Principal maakt gebruik van een expression widget, zodat gebruikers een kolom uit hun gegevens kunnen selecteren
Jaarlijks tarief, samenstellingen per jaar en jaar gebruiken number widgets met standaardwaarden en beperkingen
De operator heeft één invoerpoort die kolomgegevens levert voor de expressieparameter

schema: user-defined-operator-v0.1.0
type: uc-udf
name: Compound Amount
id: finance.compound_amount
version: '1.0.0'
description: >
  Computes the future value of an investment using compound interest.
  Formula: A = P * (1 + r/n)^(n*t)
config:
  type: object
  properties:
    principal:
      type: string
      format: expression
      title: Principal
      examples:
        - 'Select principal column or expression'
      x-ui:
        widget: expression
        port: in
    annual_rate:
      type: number
      title: Annual rate (decimal)
      default: 0.05
      minimum: 0
      examples:
        - 'e.g. 0.05 for 5%'
      x-ui:
        widget: number
    compounds_per_year:
      type: number
      title: Compounds per year
      default: 12
      minimum: 1
      examples:
        - 'e.g. 12 for monthly'
      x-ui:
        widget: number
    years:
      type: number
      title: Years
      default: 10
      minimum: 0
      examples:
        - 'Time in years (t)'
      x-ui:
        widget: number
  required:
    - principal
    - annual_rate
    - compounds_per_year
    - years
  additionalProperties: false
ports:
  input:
    - name: in
      title: Input
  output:
    - name: out
      title: Output

Voor alle beschikbare eigenschappen, datatypen, widgets en opties, zie User-defined operator YAML referentie.

Stap 3: de unity-catalogusfunctie maken

Combineer het YAML-schema en de functie Python in één CREATE FUNCTION-instructie. De YAML-configuratie wordt in de docstring aan het begin van de hoofdtekst van de functie geplaatst.

Het voorbeeld creëert de functie in main.example_output. Maak eerst het schema aan als het niet bestaat:

CREATE SCHEMA IF NOT EXISTS main.example_output

CREATE OR REPLACE FUNCTION main.example_output.compound_amount(
    principal DOUBLE,
    annual_rate DOUBLE,
    compounds_per_year INT,
    years FLOAT)
RETURNS DOUBLE
LANGUAGE PYTHON
AS $$
  """
  schema: user-defined-operator-v0.1.0
  type: uc-udf
  name: Compound Amount
  id: finance.compound_amount
  version: "1.0.0"
  description: >
    Computes the future value of an investment using compound interest.
    Formula: A = P * (1 + r/n)^(n*t)
  config:
    type: object
    properties:
      principal:
        type: string
        format: expression
        title: Principal
        examples:
          - "Select principal column or expression"
        x-ui:
          widget: expression
          port: in
      annual_rate:
        type: number
        title: Annual rate (decimal)
        default: 0.05
        minimum: 0
        examples:
          - "e.g. 0.05 for 5%"
        x-ui:
          widget: number
      compounds_per_year:
        type: number
        title: Compounds per year
        default: 12
        minimum: 1
        examples:
          - "e.g. 12 for monthly"
        x-ui:
          widget: number
      years:
        type: number
        title: Years
        default: 10
        minimum: 0
        examples:
          - "Time in years (t)"
        x-ui:
          widget: number
    required:
      - principal
      - annual_rate
      - compounds_per_year
      - years
    additionalProperties: false
  ports:
    input:
      - name: in
        title: Input
    output:
      - name: out
        title: Output
  """

  def compound_amount(principal: float,
                      annual_rate: float,
                      compounds_per_year: int,
                      years: float) -> float:
      import math
      if principal is None or annual_rate is None or compounds_per_year is None or years is None:
          return None

      if compounds_per_year <= 0:
          raise ValueError("compounds_per_year must be > 0")

      return principal * math.pow(1.0 + annual_rate / compounds_per_year,
                                   compounds_per_year * years)

  return compound_amount(principal, annual_rate, compounds_per_year, years)
$$

Stap 4: De functie testen

Test de UC-functie direct met SQL. Deze zoekopdrachten controleren drie scenario's:

$1.000 tegen 5% maandelijks samengesteld gedurende 10 jaar, wat ongeveer een rendement oplevert 1647.01
$1.000,00 tegen 5% jaarlijks gekapitaliseerd gedurende 1 jaar, wat 1050.00 oplevert
$1.000 bij 15% maandelijks samengesteld voor 1 jaar, wat ongeveer een rendement oplevert 1160.75

SELECT main.example_output.compound_amount(1000, 0.05, 12, 10);
SELECT main.example_output.compound_amount(1000, 0.05, 1, 1);
SELECT main.example_output.compound_amount(1000, 0.15, 12, 1);

Stap 5: De operator registreren

Voeg de operator toe aan uw .user_defined_operators.yaml bestand:

operators:
  - catalog: main
    schema: example_output
    functionName: compound_amount

Note

Als u dit bestand in uw gebruikersmap definieert, wordt het alleen voor u weergegeven. Voor meer informatie, zie Uw operator registreren en implementeren in Lakeflow Designer.

Stap 6: Machtigingen instellen

Toegang verlenen aan gebruikers die deze operator moeten gebruiken:

GRANT USE SCHEMA ON SCHEMA main.example_output TO `<user>`;
GRANT EXECUTE ON FUNCTION main.example_output.compound_amount TO `<user>`;

Stap 7: Gebruik de operator in Lakeflow Designer

Open in een visuele datavoorbereiding het menu Operators in het linkerpaneel en zoek de operator Compound Amount.
Sleep de operator op het canvas en verbind een invoer ermee.
Dubbelklik op de operator om het configuratiepaneel te openen en stel vervolgens de velden in.
Selecteer de operator om de bijbehorende resultaten in het uitvoervenster te bekijken.

Het configuratiepaneel van de operator omvat:

Een vervolgkeuzelijst om de primaire kolom uit uw invoergegevens te selecteren
Getalinvoer voor frequentie, samengestelde frequentie en jaren (met verstandige standaardwaarden)

Gebruikers kunnen deze operator toepassen om toekomstige waarden te berekenen voor volledige kolommen met investeringsgegevens.

Aanvullende bronnen

Feedback

Is deze pagina nuttig?

Laatst bijgewerkt om 2026-10-22