What’s wrong with Lucy?

Writing our own functions

We saw that Renfield is quite strong: he has a strength of 10, compared to Jonathan’s 5.

We could use this to experiment with making functions now. Because EdgeQL is strongly typed, you have to indicate both the input type and the return type in the signature. A function that takes an int16 and gives a float64 for example would have this signature:

function does_something(input: int16) -> float64

The -> skinny arrow is used to show the return value.

For the body of the function we do the following:

• Write using and then follow it up with () brackets,

• Write the function inside it,

• Finish with a semicolon.

Here’s a very simple function that takes a number and returns a string from it:

function make_string(input: int64) -> str
  using (<str>input);

That’s all there is to it!

Now let’s write a function where we have two characters fight. We will make it as simple as possible: the character with more strength wins, and if their strength is the same then the second player wins.

function fight(one: Person, two: Person) -> str
  using (
    SELECT one.name ++ ' wins!' IF one.strength > two.strength ELSE two.name ++ ' wins!'
  );

So far only Jonathan and Renfield have the property strength, so let’s put them up against each other:

WITH
  renfield := (SELECT Person filter .name = 'Renfield'),
  jonathan := (SELECT Person filter .name = 'Jonathan Harker')
SELECT (
  fight(jonathan, renfield)
);

It prints what we wanted to see: {'Renfield wins!'}

It might also be a good idea to add LIMIT 1 when doing a filter for this function. Because EdgeDB returns sets, if it gets multiple results then it will use the function against each one for each possible combination. The way EdgeDB handles this is through Cartesian multiplication, so let’s learn about that now.

Cartesian multiplication

Cartesian multiplication sounds intimidating but it really just means “join every item in one set to every item in the other set”. It’s easiest to understand when viewed as an illustration, which fortunately Wikipedia has already made for us. When you multiply sets in EdgeDB you are given the Cartesian product, which looks like this:

Source: user quartl on Wikipedia

This means that if we do a SELECT on Person for our fight() function, it will run the function following this formula:

• {the number of items in the first set} * {the number of items in the second set}

So if there are two in the first set, and three in the second, it will run the function six times.

To demonstrate, let’s put three objects in for each side of our function. We’ll also make the output a little more clear:

WITH
  first_group := (SELECT Person FILTER .name in {'Jonathan Harker', 'Count Dracula', 'Arthur Holmwood'}),
  second_group := (SELECT Person FILTER .name in {'Renfield', 'Mina Murray', 'The innkeeper'}),
SELECT (
  first_group.name ++ ' fights against ' ++ second_group.name ++ '. ' ++ fight(first_group, second_group)
);

Here is the output. It’s a total of nine fights, where each person in Set 1 fights once against each person in Set 2.

{
  'Count Dracula fights against The innkeeper. The innkeeper wins!',
  'Count Dracula fights against Mina Murray. Mina Murray wins!',
  'Count Dracula fights against Renfield. Renfield wins!',
  'Jonathan Harker fights against The innkeeper. The innkeeper wins!',
  'Jonathan Harker fights against Mina Murray. Mina Murray wins!',
  'Jonathan Harker fights against Renfield. Renfield wins!',
  'Arthur Holmwood fights against The innkeeper. The innkeeper wins!',
  'Arthur Holmwood fights against Mina Murray. Mina Murray wins!',
  'Arthur Holmwood fights against Renfield. Renfield wins!',
}

And if you take out the filter and just write SELECT Person for the function, you will get well over 100 results. EdgeDB by default will only show the first 100, displaying this after showing you 100 results:

... (further results hidden `\set limit 100`)

Here is all our code so far up to Chapter 11.

1. How would you write a function called lucy() that just returns all the NPC types matching the name ‘Lucy Westenra’?

   Show answer

2. How would you write a function that takes two strings and returns Person objects with names that match each string?

   Hint: try using SET OF Person as the return type.

   Show answer

3. What will the output of this be?

   Copy

   SELECT {'Jonathan', 'Arthur'} ++ {' loves '} ++ {'Mina', 'Lucy'} ++ {' but '} ++ {'Dracula', 'The inkeeper'} ++ {' doesn\'t love '} ++ {'Mina', 'Jonathan'};
   

   Show answer

4. How would you make a function that tells you how many times larger one city is than another?

   Show answer

5. Will SELECT (City.population + City.population) and SELECT ((SELECT City.population) + (SELECT City.population)) produce different results?

   Show answer

Up next: Lucy one night: “What’s that flapping against the window? Sounds like a bat or something…”