Creating an amortization schedule in snowflake - snowflake-cloud-data-platform

Question

I have a view in snowflake that gives me the following:
loan date
loan amount
maturity date
payment frequency (weekly, biweekly, semimonthly, monthly)
payment amount
I want to generate a sort of amortization schedule off of this, if you will. So if i have a loan with a date of 1/1/2022, and a maturity date of 3/9/2022 and a payment frequency of biweekly # $50 per payment, i would want to see an output like:
LoanID
Payment Date
Payment Amount
Payment Frequency
abc123
1/15/2022
$50.00
biweekly
abc123
1/29/2022
$50.00
biweekly
abc123
2/12/2022
$50.00
biweekly
abc123
2/26/2022
$50.00
biweekly
abc123
3/09/2022
$50.00
biweekly
I'm assuming i need some sort of loop while payment date < maturity date and sum(payment amount) < loan amount, but i'm not sure how to set that up properly for a view with thousands of loans. ANY help you all can provide would be incredible and i'm very grateful!

Answer 1

You can get this by writing a Recursive CTE, just remember that the default is limited to 100 iterations, if you need more loops then check this MAX_RECURSIONS parameter.
This is just an example of code, you should extend it to include some extreme data protection;
Sample data:
CREATE OR REPLACE TABLE LoanTable (
LoanID STRING,
Loan_date DATE,
Loan_amount NUMERIC(12,2),
Maturity_date DATE,
Payment_frequency STRING,
Payment_amount NUMERIC(12,2)
);
INSERT INTO LoanTable
VALUES ('abc123', '1/1/2022', 250, '3/9/2022', 'biweekly', 50);
Query:
WITH Recursive_CTE AS (
SELECT LoanID,
CASE Payment_frequency WHEN 'weekly' THEN DATEADD(WEEK, 1, Loan_date)
WHEN 'biweekly' THEN DATEADD(WEEK, 2, Loan_date)
WHEN 'semimonthly' THEN DATEADD(DAY, 15, Loan_date) -- I don't know how the semimonthly value is determined??
WHEN 'monthly' THEN DATEADD(MONTH, 1, Loan_date) END AS Payment_Date,
Payment_amount,
Loan_amount - Payment_amount AS Left_to_pay,
Payment_frequency,
Maturity_date
FROM LoanTable
UNION ALL
SELECT LoanID,
CASE Payment_frequency WHEN 'weekly' THEN DATEADD(WEEK, 1, Payment_Date)
WHEN 'biweekly' THEN DATEADD(WEEK, 2, Payment_Date)
WHEN 'semimonthly' THEN DATEADD(DAY, 15, Payment_Date) -- I don't know how the semimonthly value is determined??
WHEN 'monthly' THEN DATEADD(MONTH, 1, Payment_Date) END AS Payment_Date,
Payment_amount,
IFF(Left_to_pay - Payment_amount < 0, Left_to_pay, Left_to_pay - Payment_amount) AS Left_to_pay,
Payment_frequency,
Maturity_date
FROM Recursive_CTE
WHERE Left_to_pay > 0
)
SELECT LoanID, IFF(Payment_Date > Maturity_date, Maturity_date, Payment_Date) AS Payment_Date, Payment_amount, Left_to_pay, Payment_frequency
FROM Recursive_CTE
ORDER BY LoanID, Payment_Date;

Answer 2

Here's how to do Amortization via a JavaScript UDF with an example of how to call it. I had some trouble getting the JSON out of the function so returned it as a text string, stripped the double quotes, flattened it, and converted to a Table. Maybe someone better at JavaScript could modify it to return the table precleaned.
CREATE OR REPLACE FUNCTION AMORTIZATIONTABLE("AMOUNTFINANCED" FLOAT, "INTEREST" FLOAT, "PERIODS" FLOAT)
RETURNS STRING
LANGUAGE javascript
AS $$
const annuity = (AMOUNTFINANCED, INTEREST, PERIODS) => AMOUNTFINANCED * (INTEREST / (1 - (1 + INTEREST)**(-PERIODS)));
const balance_t = (AMOUNTFINANCED, INTEREST, P) => {
const period_movements = {
base: AMOUNTFINANCED
}
period_movements.interest = AMOUNTFINANCED * INTEREST;
period_movements.amortization = P - (AMOUNTFINANCED * INTEREST);
period_movements.annuity = P;
period_movements.final_value = Math.round((AMOUNTFINANCED - period_movements.amortization) * 100) / 100;
return period_movements;
}
const display_mortgage = (AMOUNTFINANCED, INTEREST, PERIODS) => {
var data = [];
const payements = annuity(AMOUNTFINANCED, INTEREST, PERIODS);
let movements = balance_t(AMOUNTFINANCED, INTEREST, payements);
while (movements.final_value > -.01) {
data.push(movements);
movements = balance_t(movements.final_value, INTEREST, payements);
}
return data;
}
data2 = display_mortgage(AMOUNTFINANCED, INTEREST, PERIODS);
return JSON.stringify(data2);
$$;
SELECT
INDEX + 1 AS Period,
a.VALUE:base AS CurrPrincipalBal,
a.VALUE:annuity AS TotalPayment,
a.VALUE:amortization AS PrincipalPmt,
a.VALUE:interest AS InterestPmt,
a.VALUE:final_value AS NewPrincipalBal
FROM
(SELECT * FROM TABLE(flatten(INPUT => SELECT parse_json(REPLACE(AMORTIZATIONTABLE(20000.00, 0.04, 12.00),'"',''))))) AS a;

Answer 3

Table generator is another approach.
Thanks to Simon for making this solution better. Respect!
WITH CTE_MY_DATE AS
(SELECT DATEADD(DAY, row_number() over (order by null)-1, '1900-01-01')::date AS MY_DATE FROM table(generator(rowcount => 18000)))
SELECT
date(MY_DATE) CALENDAR_DATE,
concat( decode(extract ('dayofweek_iso', date(MY_DATE)),1,'Monday',2, 'Tuesday',3, 'Wednesday',4, 'Thursday',5, 'Friday',6, 'Saturday',7, 'Sunday'),TO_CHAR(date(MY_DATE), ', MMMM DD, YYYY')) FULL_DATE_DESC
,row_number() over (partition by 1 order by calendar_date ) MOD_IS_COOL
FROM
CTE_MY_DATE
where
CALENDAR_DATE
between '2022-01-02' and '2022-09-03'
qualify
mod(MOD_IS_COOL, 14) = 0

Answer 4

So I thought I could write this "cleaner" using a table generator.
To be fair I feel this is cleaner than the recursive CTE.
To things to note, you "max loan period possible" need to be inserted for the 1000 that I have.
The bimonthly, is done by find the number of days between the monthly options, and taking "half that" it's normal to use 15 for the odd days.
But like that:
WITH loans_table(loanid, loan_date, loan_amount,
maturity_date, payment_frequency,
payment_amount) as (
SELECT * FROM VALUES
('abc123', '2022-01-01'::date, 250, '2022-03-09'::date, 'biweekly', 50)
), table_of_numbers as (
SELECT row_number() over(order by null) as rn
FROM TABLE(generator(ROWCOUNT => 1000))
/* that 1000 should be larger than any loan perdiod length you have */
), loan_enrich as (
SELECT
*
,CASE Payment_frequency
WHEN 'weekly' THEN 7
WHEN 'biweekly' THEN 14
WHEN 'semimonthly' THEN 14
WHEN 'monthly' THEN 28
END as period_lo_days
,datediff('day', loan_date, maturity_date) as loan_days
,CEIL(loan_days / period_lo_days) as loan_periods
FROM loans_table
)
SELECT
l.loanid,
CASE payment_frequency
WHEN 'weekly' THEN dateadd('week', r.rn, l.loan_date)
WHEN 'biweekly' THEN dateadd('week', r.rn * 2, l.loan_date)
WHEN 'semimonthly' THEN
case r.rn%2
when 0 then dateadd('month', r.rn/2, l.loan_date)
when 1 then dateadd('days', floor(datediff('days', dateadd('month', (r.rn-1)/2, l.loan_date), dateadd('month', (r.rn+1)/2, l.loan_date))/2), dateadd('month', (r.rn-1)/2, l.loan_date))
end
WHEN 'monthly' THEN dateadd('month', r.rn, l.loan_date)
END as payment_date,
l.payment_amount,
l.payment_frequency
FROM loan_enrich AS l
JOIN table_of_numbers AS r
ON l.loan_periods >= r.rn
ORDER BY 1, r.rn;
gives:
LOANID
PAYMENT_DATE
PAYMENT_AMOUNT
PAYMENT_FREQUENCY
abc123
2022-01-15
50
biweekly
abc123
2022-01-29
50
biweekly
abc123
2022-02-12
50
biweekly
abc123
2022-02-26
50
biweekly
abc123
2022-03-12
50
biweekly
So this can be boosted, to have semimonthly15 which is always 15 days later, and we can do some do some filtering incase the number of rows was more than we need, and we can show logic for handling a final payment that is smaller than the prior payments:
WITH loans_table(loanid, loan_date, loan_amount,
maturity_date, payment_frequency,
payment_amount) as (
SELECT * FROM VALUES
('abc123', '2022-01-01'::date, 250, '2022-03-09'::date, 'biweekly', 50),
('abc124', '2022-01-01'::date, 249, '2022-03-09'::date, 'semimonthly', 50),
('abc125', '2022-01-01'::date, 249, '2022-03-09'::date, 'semimonthly15', 50)
), table_of_numbers as (
SELECT row_number() over(order by null) as rn
FROM TABLE(generator(ROWCOUNT => 1000))
/* that 1000 should be larger than any loan perdiod length you have */
), loan_enrich as (
SELECT
*
,CASE Payment_frequency
WHEN 'weekly' THEN 7
WHEN 'biweekly' THEN 14
WHEN 'semimonthly' THEN 14
WHEN 'semimonthly15' THEN 14
WHEN 'monthly' THEN 28
END as period_lo_days
,datediff('day', loan_date, maturity_date) as loan_days
,CEIL(loan_days / period_lo_days) as loan_periods
FROM loans_table
)
SELECT
l.loanid,
CASE payment_frequency
WHEN 'weekly' THEN dateadd('week', r.rn, l.loan_date)
WHEN 'biweekly' THEN dateadd('week', r.rn * 2, l.loan_date)
WHEN 'semimonthly' THEN
case r.rn%2
when 0 then dateadd('month', r.rn/2, l.loan_date)
when 1 then dateadd('days', floor(datediff('days', dateadd('month', (r.rn-1)/2, l.loan_date), dateadd('month', (r.rn+1)/2, l.loan_date))/2), dateadd('month', (r.rn-1)/2, l.loan_date))
end
WHEN 'semimonthly15' THEN
case r.rn%2
when 0 then dateadd('month', r.rn/2, l.loan_date)
when 1 then dateadd('days', 15, dateadd('month', (r.rn-1)/2, l.loan_date))
end
WHEN 'monthly' THEN dateadd('month', r.rn, l.loan_date)
END as payment_date,
l.payment_amount,
l.payment_frequency,
l.loan_amount,
l.loan_amount - least(l.loan_amount, l.payment_amount * r.rn) as still_to_pay,
least(l.loan_amount - least(l.loan_amount, l.payment_amount * (r.rn-1)), l.payment_amount) as this_payment
FROM loan_enrich AS l
JOIN table_of_numbers AS r
ON l.loan_periods >= r.rn
WHERE this_payment > 0
ORDER BY 1, r.rn
LOANID
PAYMENT_DATE
PAYMENT_AMOUNT
PAYMENT_FREQUENCY
LOAN_AMOUNT
STILL_TO_PAY
THIS_PAYMENT
abc123
2022-01-15
50
biweekly
250
200
50
abc123
2022-01-29
50
biweekly
250
150
50
abc123
2022-02-12
50
biweekly
250
100
50
abc123
2022-02-26
50
biweekly
250
50
50
abc123
2022-03-12
50
biweekly
250
0
50
abc124
2022-01-16
50
semimonthly
249
199
50
abc124
2022-02-01
50
semimonthly
249
149
50
abc124
2022-02-15
50
semimonthly
249
99
50
abc124
2022-03-01
50
semimonthly
249
49
50
abc124
2022-03-16
50
semimonthly
249
0
49
abc125
2022-01-16
50
semimonthly15
249
199
50
abc125
2022-02-01
50
semimonthly15
249
149
50
abc125
2022-02-16
50
semimonthly15
249
99
50
abc125
2022-03-01
50
semimonthly15
249
49
50
abc125
2022-03-16
50
semimonthly15
249
0
49