fql | Filter Query Language | Parser library

I think you want:

Not too familiar with FQL, but I am somewhat familiar with SQL languages. Essentially, database languages usually treat all of your values as strings until they don't need to anymore. Instead, your query should use the string definition that FQL is expecting. I believe it should be OPEN or CLOSED in your case. You can simply have an if statement in java to determine whether to search for "OPEN" or "CLOSED".

To answer your second question, I don't know for FQL, but if that is what is returned, then your approach with a lamda seems to be fine. Not much else you can do about it from your end other than hope that you get a different way to get entries in API form somewhere in the future. At the end of the day, an O(n) operation in this context is not too bad, and only having to return a hundred or so orders shouldn't be the most painful thing in the world.

If you are truly worried about this, you can break up the request into portions, so you return only the first 100, then when frontend wants the next set, you send the next 100. You can cache the results too to make it very fast from the front-end perspective.

The reason is because FaunaDB doesn't support reading empty/null value the way you think it does. You need to use a special Bindings to do that.

Make sure to check out https://docs.fauna.com/fauna/current/tutorials/indexes/bindings.html#empty for a more thorough explanation and examples.

My understanding of how bindings work would yield the following code. I haven't tested it though and I'm not sure it works.

You need a special binding index:

If it's always exactly two ids, you can fetch both objects in a single query easily using field aliases:

Yes it’s possible Enable nodetool settraceprobability 1.0 You can find the query in system_traces.events table

Other option is increasing the logging levels to all and grep “native transport request -Id

We have a Join FQL function, but it might not be what you expect. Join is rather a traverse that goes from one set of references (e.g. a set of user references) via an index to another set of references (e.g. the loans). I call it 'traverse' since it's essentially going to replace the user references with the loan references and therefore you don't have the data together as you require it. Just wanted to clarify that before you lose time trying to figure out how to do it with Join.

In fauna, you have to think slightly different. Think about how you would do it in a regular procedural programming language: "get all loans, map over loans, for each loan, get the user".

• Fetch an initial Page of documents (e.g. loans), with Paginate(Match(....))
• Loop over these (in FQL, not in the host language, it's still ACID) with Map() and Lambda()
• Within the lambda:
  • If that document contains a reference to the other documents you need (e.g. user), just use Get() to fetch that reference.
  • If the linked document contains the reference or it's contained in another collection (e.g. objectified relation in many to many) then use an index (e.g. Match(Index(... some value ... )) to retrieve the linked documents. Since you will in this case receive multiple results. Use Get on that index if it's one value that you expect or Paginate on the index if you expect many (you get to paginate on multiple levels)

An example, on how to get nested documents has already been written out here:

How to get nested documents in FaunaDB?

Imagine you would have stored the User reference directly it would be this:

you can use this FQL:

It turns out that by default, you cannot run nodetool commands in the Dockerfile when building the container; rather, they have to be run 'manually' in the running container. So I adapted the Dockerfile to the following:

You can use a client like curl or any GraphQL client. With curl you can issue something like: