Null and nullable

this video is about nothing or rather the absence of [Music] something hi and welcome back today we're going to be talking about null and nullable I'm going to be giving you some tips on where and how to use them and this is the latest in my video on robust module design uh link to which I will put up here before we dive in um if you do like these videos please give us a subscribe to the channel it'd be much appreciated

so what are we going to talk about today first of all we're going to be looking at what is null we're going to be looking at how to use nulls especially in conditions uh and then a bit more of an advanced use case in terms of how to use nulls in conditions where you don't know the value uh until after apply such as resource IDs coming in and things like that then we're going to move on to nullable how can nullable help simplify the logic in your module and if you're unsure about whether you should use nullable or not I have a golden rule

that you can use to make your decision for you so let's dive in so what is null null is as defined by hashicorp in their docs there is one special value that has no type h we'll see a null value represents an absence or a mission if you set an argument of a resource to be null terraform behaves though you had completely omitted it omitted it it will use the arguments default value if it has one or raise an error if the argument is mandatory null is most useful in conditional Expressions so you can dynamically admit an argument if a

condition isn't met so yeah we use NES a lot we're going to look at how to use them intern Expressions um to conditionally create resources and things like that really common however I do take a slight issue with Hashi corp's definition there because in the work that I do uh writing code um especially around like linting rules and providers and stuff null values do have an underlying type so if we look here we can see the null Val uh function

which takes one parameter of the type and you have to supply a type to that null Val um so it can be a null value of a string or a null value of a object or or whatever nevertheless it does need a type now quite often people will use the underlying Dynamic type for this but still null values have a type sorry bit of a chip on my shoulder about that one by the way this one the thing that was on the screen just then is from the uh Cai package so the cty package that

terraform uses for its type handling system under under the hood so let's have a look now how we can dive into the code and see some examples of how we can use null starting off with something quite simple and then moving on to a more advanced case where we need to uh pass in a dependency but we don't know what that dependency is till after apply for example an actual resource ID but we still need to conditionally create the resource um so yeah let's

have a look at that and see how it goes so here we are with a really really simple example to start with as ever with me there is a little problem a little hiccup that you might encounter and then we'll come on to that in a second so we have a variable called my dependency it is of type string and the default is null based upon that variable we have a resource called condition and we're using a Turner expression here I'm sure you know what these are but for those that you those that don't you have

an expression so something that evaluates to either true or false and then you uh if that expression is true the count will be one if the expression is false the count will be zero tary uh not notations used in quite a lot of programming languages so yeah V my dependency is not equal to null well the default is null so the default then will be zero so won't create this resource so if I go to my terminal and I type teron plan um there is nothing to do okay um

however if I change this to uh value doesn't really matter what it is I terraform plan there it says it's going to create that resource and it's some zero index of it because we using count cool that's what you would expect right of course is there a problem of course there's a problem the problem is if we look in my well-named

problem directory problem is where we want to pass in a resource ID say and that resource ID is not known until after apply so what happens then so we've got our terraform data trusty terraform data resource here and this has got one input and one output the input I'm just setting to a uh a constant here the output is calculated so it's only known after apply

and I'm feeding that in to my module here which I've called test I'm sourcing from The Parent Directory and this is really common so what what happens here so let's go CD problem and terraform plan problem problem is that the count value depends on resource attributes that cannot be determined till after apply so in forre and count you cannot have values at the moment that need that are only known and uh before for apply

time so what do we do well what we actually do is change the input schema slightly because we still want to have the condition so we still want to be able to test for null it's a really really easy way of creating that resource or not so let's go back to our null condition here and let's change this object and let's call it let's call it resource ID what it is okay so now what we've got is my dependency is an

object with resource ID equals string what that enables us to do is test whether the object is null or not but we can still input the resource ID into here even though it's not known it's after apply so it's a really really nice pattern to use and let's demonstrate how we might do that so obviously this would be a breaking change on module if you were making changes but I'm hoping that by listening to this now and and learning that you

can implement this to start with and not make these mistakes so if we go back into our problem what we need to do now is to change this because this is now an object so and it's going to be resource ID res resource ID okay um so that sorry that's not right it's here my dependency that's the issue so it's in there

there you go so now what I've done is I've wrapped the unknown value inside this object but terraform is able to understand that the object itself is not null the object has something in it it just doesn't know what it is yet and that sorts our problem out because I think all find now is that there you go so this is the dependent resource from the root module it's going to create that output is known after apply it's then going to create the conditional resource

because it knows that the object is not now it just doesn't know what's inside the object yet and you can see here that the input is known after apply and that will work so that's the first pattern that I want I want people to remember is if you're going to be passing in stuff that's not known till after apply like as your resource IDs you can't use them in conditions well you can but it won't be a robust design it will fail like you've just seen here now this is a tricky one as well because what tends to happen is that if you develop your module in an iterative

fashion sometimes you'll be going terraform uh apply and you're checking things and then you add this condition in and it's still fine because you've created the dependent resource before so it exists so it knows what that knows what that resource ID is so when you're developing your modules always do a destroy and apply to fully test in obviously an automated test framework can help with this so yeah lesson one wrap your unknown values in an object which could then be tested for null um if uh that pattern applies to you okay

let's now move on to nullable okay here we are again you can see that we have a another common scenario where you are creating a resource with a for each so we've got a variable called fo just like how many FS do you want um and it's going to do a four each and that's a map of an object with the string fo inside it so yeah pretty common simple example the default that I've given it is an empty object so

that empty map sorry empty object but essentially this is a a map of objects and then it's empty so when this evaluates it will be empty and you'll get no Foo this is exactly what we want so just to prove that there you go terraform plan no fo but what happens if some unsuspecting consumer of your module supplies null in here that happens so can't do it because

it doesn't can't do a four each on a n on a null value so what do we do well what some people do is this um we go okay V Fus is co-pilot's way ahead of me as usual if V Fus is not equal to null then V fuse if not give me the empty so that's fine and it works uh as you'll see uh that works no Foo but it's a rubbish isn't it it's a it's harder to

read it's harder to understand if only there was a simpler way guess what there's a simpler way what we need to do is put that back and put nullable is false in there so the default value for nullable is true so you don't need to set it it it's in fact you shouldn't set it really um what this will do is if someone tries to pass null into hereone will give them an error say no you can't it can't be null it must be something else so so what we tend that is a really common pattern

default empty map nullable is false is a really really robust way of Designing these things but as we know null has a meaning null means I don't want this um so when is a good rule for when I should set nullable on my variable or not so the trick is if you want a golden rule to know when you should use null or not ask

yourself this is there a semantic difference between a null value and an empty map or an empty collection quite often when you're doing four each with a map of object you'll find that there is actually no semantic difference so there's no meaningful difference between a null value because a null value would indicate that I don't want any fo in this in this thing that's fair and an empty map would indicate that I don't want any foods so there's

no difference between the two so to save yourself trouble of unnecessary tary Expressions you should set nullable in these values to be uh false and that will mean that the default value is empty and the caller can only Supply either an empty map or a map filled with objects so yeah I hope that helps so there we have it that is null and nullable so what did we learn that that null is the absence of a value even

though underlying it still has a type and that null is typically used in conditions so when we if you pass something into your module uh which has a null value you can use that null value to determine if you do something or not using count we also learn that sometimes passing in values that aren't known to after apply that is then problematic so the way to get around that is to wrap that in an object so the UNM value is an attribute of your object but you can still test for the object being null or

not finally we looked at nullable and we learned that for collection values when you're using for each so maps of objects then using nullable is normally a good idea because there's no semantic difference between an empty map and a null value you still means you don't want any of the things however for other values cons the golden rule for nullable is is there a semantic difference between a null value and an empty value so for for primitive

types it's typically not normal to set to set nullable equals false because there is definitely a difference between an empty string and a null string and there's definitely a value uh difference between a zero number and a null number so yeah I really hope that's useful as ever if you have liked the content please click on that subscribe button and a like would be much appreciated as well I will see you next time