Lernprogramm: Rechneroperator für Verbundzinsen

Important

Dieses Feature befindet sich in der Public Preview.

Dieses Tutorial zeigt Ihnen, wie Sie für Lakeflow Designer einen Python-UDF-Operator erstellen, der Zinseszinsen berechnet. Verwenden Sie dieses Beispiel, um die Grundlagen zum Erstellen von Operatoren zu erlernen, die einzelne Werte oder Spalten umwandeln. Weitere Informationen finden Sie unter Benutzerdefinierte Operatoren in Lakeflow Designer.

Übersicht

Dieses Lernprogramm führt Sie durch das Erstellen eines benutzerdefinierten Operators mithilfe eines Python UDF. Der Operator berechnet den zukünftigen Wert einer Investition mithilfe der Zinsformel, A = P × (1 + r/n)^(n×t)wobei:

P = Prinzipal (Anfangsbetrag)
r = Jahreszinssatz (als Dezimalzahl)
n = Anzahl der Verbundperioden pro Jahr
t = Zeit in Jahren

Step 1: Schreiben und Testen der Python-Funktion

Definieren Sie zunächst die Kernfunktion Python, die die Berechnung ausführt. Testen Sie sie in einer Notizbuchzelle, um sicherzustellen, dass sie ordnungsgemäß funktioniert.

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)

Sie können die Funktion mit dem folgenden Code testen:

# $1,000 invested at 5% annual rate, compounded monthly for 10 years
compound_amount(1000, 0.05, 12, 10)
# Expected result: ~1647.01

Schritt 2: Erstellen des YAML für den Operator

Die YAML-Konfiguration definiert, wie der Operator im Lakeflow-Designer angezeigt wird. Für diesen Operator:

Prinzipal verwendet ein expression Widget, damit Benutzer eine Spalte aus ihren Daten auswählen können.
Jährliche Rate, Verzinsungen pro Jahr und Jahre verwenden number Steuerelemente mit Standardwerten und Beschränkungen
Der Operator verfügt über einen Eingabeport, der Spaltendaten für den Ausdrucksparameter bereitstellt.

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

Eine umfassende Anleitung zu allen verfügbaren Eigenschaften, Datentypen, Widgets und Optionen finden Sie in der YAML-Referenz für benutzerdefinierte Operatoren .

Schritt 3: Erstellen der Unity-Katalogfunktion

Kombinieren Sie das YAML-Schema und Python Funktion in einer einzelnen CREATE FUNCTION-Anweisung. Die YAML-Konfiguration wird am Anfang des Funktionstexts in die Docstring-Datei eingefügt.

CREATE OR REPLACE FUNCTION main.my_schema.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)
$$

Schritt 4: Testen der Funktion

Testen Sie die UC-Funktion direkt mit SQL:

-- Test 1: $1,000 at 5% compounded monthly for 10 years
SELECT main.my_schema.compound_amount(1000, 0.05, 12, 10)
-- Expected: ~1647.01

-- Test 2: $1,000 at 5% compounded annually for 1 year
SELECT main.my_schema.compound_amount(1000, 0.05, 1, 1)
-- Expected: 1050.00

-- Test 3: $1,000 at 15% compounded monthly for 1 year
SELECT main.my_schema.compound_amount(1000, 0.15, 12, 1)
-- Expected: ~1160.75

Schritt 5: Registrieren des Operators

Fügen Sie den Operator Ihrer .user_defined_operators.yaml-Datei hinzu:

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

Note

Wenn Sie diese Datei in Ihrem Benutzerordner definieren, wird sie nur für Sie angezeigt. Weitere Informationen finden Sie unter Machen Sie Ihren Operator auffindbar.

Schritt 6: Einrichten von Berechtigungen

Gewähren Sie Zugriff auf Benutzer, die diesen Operator verwenden müssen:

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

Den Operator in Lakeflow Designer verwenden

Nach der Registrierung wird der Operator in Lakeflow Designer mit:

Eine Dropdownliste zum Auswählen der Hauptspalte aus Ihren Eingabedaten
Zahleneingaben für Rate, Verbundhäufigkeit und Jahre (mit sinnvollen Standardwerten)

Benutzer können diesen Operator anwenden, um zukünftige Werte für ganze Spalten von Investitionsdaten zu berechnen.

Feedback

War diese Seite hilfreich?

Last updated on 2026-06-01