vin | Vehicle Identification Number ) validation

useContext hook: React context

Redux: Official Redux document

And btw, react-router supports passing states as props but I don't recommend it

The dictionary is actually quite simple. We have the key states, and it's value is a list containing sub dictionaries. If we iterate through this list we can easily index state_id and state_name. Now I don't know how you want to store this gathered data, so I assumed it would be best to put each group of "state_id" & "state_name" in a tuple.

QLDB doesn't currently offer an ALTER TABLE capability. You'd have to DROP the table and re-create it. This counts against your table limits, so don't do it too often.

QLDB is schema-less, so you can change your field names and/or the structure of your documents anytime you want to, simply by writing new revisions to your documents in the new format. The journal will still contain the old revisions, however. If your application has any functionality that uses the history() function to access old revisions, then it needs to be able to gracefully handle variations in the document format.

It is important to note that QLDB is not optimized for scanning large volumes of data. It's optimized for targeted queries against an index using an equality operator. A query like "SELECT * FROM table" will scan the entire table. This is an anti-pattern for QLDB and will not perform well as your ledger grows. So if you change your document format, running a SELECT * and updating every document to the new format may be more work than you realize. First, that SELECT * scan query may time-out or it may be aborted with an Optimistic Concurrency Control exception because another process inserted a document in the table. Second, you'd have to do it in batches of 40 documents at a time because of the limit to the number of documents in a transaction.

All of this is to say that making your application resilient to schema changes is a good idea. :-)

The xml parser is choking on ampersands that aren't correct entities & -> &

This should do, I'm just not sure of what the source type object types are for the variables holding the values.

I found 5 bugs in your code. After fixing these bugs, your program seems to work. I haven't tested all kinds of input, though.

In the function createCarList, the line

car *cars=(car*)malloc(sizeof(car));

does not write to your global variable cars. Instead, it creates a new local variable with that name, and writes to that one instead. If you want to write to the global variable, you should write cars=(car*)malloc(sizeof(car)); instead. However, I don't see much point in that, as this will do nothing else than make cars point to a mostly uninitialized node. It would probably be best to remove the function createCarList completely.

In the function addNewCar, in the lines

Unlike in MySQL, in Oracle we cannot refer to an alias in the HAVING clause (aliases can only be referenced in the ORDER BY clause). One workaround would be to put your current logic into a CTE and then filter it.

As @skuruppu mentioned in the comment above, your current example is mostly fine for what you are describing. It does however implicitly assume a couple of things, as you are not executing the read and the insert in the same transaction. That means that the two operations together are not atomic, and other transactions might update or delete the record between your two operations.

Also, your approach assumes that scenario A (record does not exist) is the most probable. If that is not the case, and it is just as probable that the record does exist, then you should execute the read in the transaction before the write.

You should also do that if there are other processes that might delete the record. Otherwise, another process might delete the record after you tried to insert the record, but before you try to read it (outside the transaction).

The above is only really a problem if there are other processes that might delete or alter the record. If that is not the case, and also won't be in the future, this is only a theoretical problem.

So to summarize:

1. Your example is fine if scenario A is the most probable and no other process will ever delete any records in the cars table.
2. You should execute the read before the write using the same read/write transaction for both operations if any of the conditions in 1 are not true.

The read operation that you are using in your example is the most efficient way to read a single row from a table.

There would be a record of the original record and its deletion in the ledger, which would be available through the history() function, as you pointed out. So there's no way to hide the bad behavior. It's a matter of hoping nobody knows to look for it. Again, as you pointed out.

You have a couple of options here. First, QLDB rolled-out fine-grained access control last week (announcement here). This would let you, say, prohibit deletes on a given table. See the documentation.

Another thing you can do is look for deletions or other suspicious activity in real-time using streaming. You can associate your ledger with a Kinesis Data Stream. QLDB will push every committed transaction into the stream where you can react to it using a Lambda function.

If you don't need real-time detection, you can do something with QLDB's export feature. This feature dumps ledger blocks into S3 where you can extract and process data. The blocks contain not just your revision data but also the PartiQL statements used to create the transaction. You can setup an EventBridge scheduler to kick off a periodic export (say, of the day's transactions) and then churn through it to look for suspicious deletes, etc. This lab might be helpful for that.

I think the best approach is to manage it with permissions. Keep developers out of production or make them assume a temporary role to get limited access.