ArangoDB AQL：查找顺序数据中的差距

Question

I've been given data to build an application that has sequential data in the form of part numbers of products: "000000", "000001", "000002", "000010", "000011"... . The previous application was an old MS Access database that didn't have any gap filling features in the part number generator, hence the gap between "000002" and "000010" (Yes, they are also strings, but I can work with that...).

We could continue to increment based on the last value and ignore the gaps, however, in an attempt to use all numbers available to us with our naming scheme, we'd like to be able to fill the gaps. Our naming scheme describes the "product family" with the first two digits such that: [00]0000 would be a different family from [02]0000 .

I can find the starting and ending values using something like:

let query = `
  LET first = (
    MIN(
      FOR part in part_search
        SEARCH STARTS_WITH(part.PartNumber, @family)
        RETURN part.PartNumber
    )
  )
  LET last = (
    MAX(
      FOR part in part_search
        SEARCH STARTS_WITH(part.PartNumber, @family)
        RETURN part.PartNumber
    )
  )
  RETURN { first, last }
`

The above example returns: {first: "000000", last: "000915"}

Using ArangoDB and AQL, how could I go about finding these gaps? I've found some SQL examples but I feel the features of AQL are a bit more limiting.

Thanks in advance!

Answer 1

To start with, I think your best bet for getting min/max values is using aggregates:

FOR part in part_search
    SEARCH STARTS_WITH(part.PartNumber, @family)
    COLLECT x = 1
    AGGREGATE first = MIN(part.PartNumber), last = MAX(part.PartNumber)
    RETURN {
        first: first,
        last: last
    }

But that won't really help when trying to find gaps. And you're right - SQL has several logical constructs that could help (like using variables and cursor iteration), but even that would be a pattern I would discourage.

The better path might be to do a "brute force" approach - compare a table containing your existing numbers with a table of all numbers, using a native method like JOIN to find the difference. Here's how you might do that in AQL:

LET allNumbers = 0..9999
LET existingParts = (
    FOR part in part_search
        SEARCH STARTS_WITH(part.PartNumber, @family)
        LET childId = RIGHT(part.PartNumber, 4)
        RETURN TO_NUMBER(childId)
)
RETURN MINUS(allNumbers, existingParts)

The x..y construct creates a sequence (an array of numbers), which we use as the full set of possible numbers. Then, we want to return only the "non-family" part of the ID (I'm calling it "child"), which needs to be numeric to compare with the previous set. Then, we use MINUS to remove elements of existingParts from the allNumbers list.

One thing to note, that query would return only the "child" portion of the part number, so you would have to join it back to the family number later. Alternatively, you could also skip string-splitting, and get "fancy" with your list creation:

LET allNumbers = TO_NUMBER(CONCAT(@family, '0000'))..TO_NUMBER(CONCAT(@family, '9999'))
LET existingParts = (
    FOR part in part_search
        SEARCH STARTS_WITH(part.PartNumber, @family)
        RETURN TO_NUMBER(part.PartNumber)
)
RETURN MINUS(allNumbers, existingParts)