Tutoriel : Opérateur de calcul des intérêts composés

Important

Cette fonctionnalité est disponible en préversion publique.

Ce tutoriel décrit la création d’un opérateur UDF Python pour Lakeflow Designer qui calcule l’intérêt composé. Utilisez cet exemple pour découvrir les principes fondamentaux des opérateurs de transformation qui transforment des valeurs individuelles ou des colonnes. Pour en savoir plus, consultez les opérateurs définis par l’utilisateur dans Lakeflow Designer.

Vue d’ensemble

Ce tutoriel vous guide tout au long de la création d’un opérateur défini par l’utilisateur à l’aide d’une fonction UDF Python. L’opérateur calcule la valeur future d’un investissement à l’aide de la formule d’intérêt composée, A = P × (1 + r/n)^(n×t)où :

P = Principal (montant de départ)
r = Taux d’intérêt annuel (comme décimal)
n = Nombre de périodes composées par année
t = Temps en années

Step 1 : Écrire et tester la fonction Python

Tout d’abord, définissez la fonction de base Python qui effectue le calcul. Testez-le dans une cellule de bloc-notes pour vous assurer qu’il fonctionne correctement.

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)

Vous pouvez tester la fonction avec le code suivant :

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

Étape 2 : Créer le YAML pour l’opérateur

La configuration YAML définit la façon dont l’opérateur apparaît dans Lakeflow Designer. Pour cet opérateur :

Principal utilise un expression widget afin que les utilisateurs puissent sélectionner une colonne à partir de leurs données
Taux annuel, Composés par année et Années utilisent number des widgets avec des valeurs par défaut et des contraintes
L’opérateur a un port d’entrée qui fournit des données de colonne pour le paramètre d’expression

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

Consultez la référence YAML de l’opérateur défini par l’utilisateur pour obtenir un guide complet sur toutes les propriétés, types de données, widgets et options disponibles.

Étape 3 : Créer la fonction Catalogue Unity

Combinez le schéma YAML et la fonction Python en une seule instruction CREATE FUNCTION. La configuration YAML se place dans la docstring au début du corps de la fonction.

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)
$$

Étape 4 : Tester la fonction

Testez la fonction UC directement avec 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

Étape 5 : Inscrire l’opérateur

Ajoutez l’opérateur au fichier .user_defined_operators.yaml :

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

Note

Si vous définissez ce fichier dans votre dossier utilisateur, il s’affiche uniquement pour vous. Pour plus d’informations, consultez Rendre votre opérateur détectable.

Étape 6 : Configurer les autorisations

Accordez l’accès aux utilisateurs qui doivent utiliser cet opérateur :

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

Utilisation de l’opérateur dans Lakeflow Designer

Une fois inscrit, l’opérateur s’affiche dans Lakeflow Designer avec :

Liste déroulante pour sélectionner la colonne principale dans vos données d’entrée
Nombre d’entrées pour le taux, la fréquence composée et les années (avec des valeurs par défaut sensibles)

Les utilisateurs peuvent appliquer cet opérateur pour calculer les valeurs futures pour les colonnes entières des données d’investissement.

Commentaires

Est-ce que cette page vous a été utile?

Last updated on 2026-06-01