C code displaying random datasets

Your code has a number of issues.

It is often better to layout the code in reverse order. This avoids the need for local prototypes. For example, main goes last in the file and the functions it calls are above it. inline functions must be defined before they are used - another reason for doing things backwards. Note that the compiler can decide for itself what should be inline and what not, so using 'inline' is normally unnecessary.

You have defined emum E_TYPE but not used it in struct Item, where it is needed. Instead you use unsigned short int type. Note that all-caps names are usually constants, so E_TYPE would be better as type. Function randomType should return an enum type, not a short and should use the values defined for the enum. The union in your Item struct need not have a name and its field names are verbose. Here is how I would simplify it:

typedef struct {
    enum type type;
    DBID id;
    union {
        Person person;
        Company company;
    };
} Item;

General point: don't put the type and variable on separate lines. Nobody does that.

Functions with no parameters should be defined with a void in the parameter list. The compiler should warn you about that (compile with warnings turned on - use at least the option -W with gcc).

In your randomCompanyName etc functions, the name list should be const. When selecting the random name using

return nameList[randr(0, 4)];

instead of an explicit 4, you should derive the value from the array:

const char* nameList[] = {
    "Microsoft",
    "Valve",
    "Vamonos pest",
    "Hello folks!",
    "Just a program inc"
};
const int listSize = sizeof nameList / sizeof nameList[0];
return nameList[randr(0, listSize - 1)];

You can do this only if you omit the size of the array.

Your randr is almost correct, but should divide by RANDMAX + 1

double scaled = rand() / (1.0 + RAND_MAX);

Your populateItems function is not very readable. For a start, it is generally best not to exceed about 80 characters per line. It is also odd to create an Item and then copy that into the global array. Why not create it directly in the correct array entry? Also, define the loop variable in the loop, not above it.

Your use of strncpy in the loop is a problem. strncpy does not do what you might expect when there is not enough space. It does not terminate the truncated string! To do it properly you must terminate each string explicitly. This is messy. The alternative copy function strlcpy that gets it right but is not universally available (and hence is non-portable). An alternative, perhaps nicer , is to get your randomCompanyName etc functions, to fill the string buffer themselves:

static char* randomCompanyName(char *buf, size_t size)
{
    static char* nameList[] = { ...
    };
    const int listSize = sizeof nameList / sizeof nameList[0];
    const char *name = nameList[randr(0, listSize - 1)];
    strncpy(buf, name, size);
    buf[size - 1] = '\0';
    return buf;
}

Putting these together, populateItems then becomes rather easier to read:

static void populateItems(void)
{
    for (int i = 0; i < ITEMS_COUNT; ++i) { // note < not !=
        Item *it = &itemList[i];
        it->id = i + 1;
        it->type = randomType();

        if (it->type = TYPE_PERSON) {
            randomPersonName(it->person.name, sizeof it->person.name);
            randomPersonSurname(it->person.surname, sizeof it->person.surname);
        } else {
            randomCompanyName(it->company.name, sizeof it->company.name);
        }
    }
}

Your dumpItems uses sprintf to create a string but overwrites the first part ("Row %ld: { dbID: %d,") with the second part ("%s name: %s, surname: %s }") as it does not index into str. sprintf like strcpy etc is a common source of buffer overruns. You could use snprintf instead, but really why bother? It would be much easier just to print the two parts of the string directly to stdout.