MEOW | MEOW is a fork of COW that uses whitelist mode | Application Framework library

You can use Context's to register the child component:

An interface holds two things: a pointer to the underlying data, and the type of that data. So, when you declare

As you've seen there is no REWRITE of the primary index, because as soon as you change that the REWRITE is not changing the previous read record but the one with the new primary record - if it exists.
This is how ORGANIZATION INDEXED works.

The thing that is commonly done:

• READ old-record (possibly WITH LOCK)
• if you don't have that already: save the old values of the key fields
• place the new values in the key fields, then WRITE, ideally with an INVALID KEY clause to catch this case
• result is one of:
  • INVALID KEY condition (= duplicate): - you have to decide if that should be DELETED (if yes, then re-read the old record again, "update" its key field and do the INSERT again, otherwise abort either with a manual error message or by letting the runtime system handle the duplicate key)
  • NOT INVALID KEY condition - everything is fine
• place the saved (old) value in the key fields, then DELETE (as you'd otherwise have the record in the file with both the old and the new key values)

Depending on the rules in your environment you may need to READ with the new key and therefore don't ever get into the INVALID KEY condition during WRITE.

Yes, all this is correct.

There's a second reason for this design: it allows the compiler to verify that the operations you're performing on the vector elements are using memory in a safe way, relative to how they're stored.

For example, if you had a method on ChattyAnimal that mutates the animal (i.e. takes a &mut self argument), you could call that method on elements of a Vec> as long as you had a mutable reference to the vector; the Rust compiler would know that there could only be one reference to the ChattyAnimal in question (because the only reference is inside the Box, which is inside the Vec, and you have a mutable reference to the Vec so there can't be any other references to it). If you tried to write the same code with a Vec>, the compiler would complain; it wouldn't be able to completely eliminate the possibility that your code might be mutating the animal at the same time as the code that called it was in the middle of trying to read the animal, which might lead to some inconsistencies in the calling code.

As a consequence, the compiler needs to know that all the elements of the Vec have their memory treated in the same way, so that it can check to make sure that a reference to some arbitrary element of the Vec is being used appropriately.

(There's a third reason, too, which is performance; because the compiler knows that this is a "vector of Boxes" or "vector of Rcs", it can generate code that assumes a particular storage mechanism. For example, if you have a vector of Rcs, and clone one of the elements, the machine code that the compiler generates will work simply by going to the memory address listed in the vector and adding 1 to the reference count stored there – there's no need for any extra levels of indirection. If the vector were allowed to mix different allocation schemes, the generated code would have to be a lot more complex, because it wouldn't be able to assume things like "there is a reference count", and would instead need to (at runtime) find the appropriate piece of code for dealing with the memory allocation scheme in use, and then run it; that would be much slower.)

You may not need an ODM. With serde (which is used by all those ODMs), the "schema" is implemented on the struct itself, so you can add any methods you want with an impl block. It would look something like this:

No need to use a regex when Python's standard in operator will do the job, IMO:

ClassType should be declared as

The first argument of passed to init is always implicitly the constructed instance. You should handle this in the definition too:

You can use string_split() and some string operations: