standards

What's the sql standard to get the last inserted id? If there is such a thing. mysql: LAST_INSERT_ID() postgresql: ... RETURNING f_id mssql: SCOPE_IDENTITY() ... more examples here ... I mean, all databases have different implementations for that, there isn't a standard for such a common task? RichardTheKiwi See this answer Retrieve inserted row ID in SQL In short, there is no cross database way to do this, except MAX(ID) - but that is not a guaranteed result and has many many pitfalls, e.g. other inserts can come between last insert and max query cannot be used with high transaction tables

The course that I am currently doing uses brackets in its WHERE clauses like so: SELECT bar FROM Foo WHERE (CurrentState = 'happy'); Is this standard sql ? If not then why use them? Doesn't seem to be used in the Date & Darwen book I have. EDIT Just to clarify - I'm referring to 1992 sql standards Yes. You can use parenthesis to bind components of where clauses. This isn't necessary in your example, but if you had multiple and and or components, you might need parenthesis to either ensure correct order of operations or simply to self-document the query. Example 1: select * from foo where

I thought those terms where synonymous, but a note in MISRA regarding dead code indicates this to be wrong? What's the difference? Is one a subset of the other? Dead code - code that is executed but redundant, either the results were never used or adds nothing to the rest of the program. Wastes CPU performance. function(){ // dead code since it's calculated but not saved or used anywhere a + b; } Unreachable code - code that will never be reached regardless of logic flow. Difference is it's not executed. function(){ return x; // unreachable since returned a = b + c; } Dead Code Code that

Paragraph 6.7.3.8 of the C99 spec states If the specification of an array type includes any type qualifiers, the element type is so-qualified, not the array type. If the specification of a function type includes any type qualifiers, the behavior is undefined. In the rationale (logical page 87, physical page 94), an example of casting a flat pointer to a (variable length) array pointer is given. void g(double *ap, int n) { double (*a)[n] = (double (*)[n]) ap; /* ... */ a[1][2] /* ... */ } Certainly if the array ap is not modified within the function, it should be marked const, however the cast in

Does the C99/C++11 standard guarantee that sizeof(size_t) == sizeof(void*) is always true? size_t f(void* p) { return (size_t)(p); // Is it safe? } void* f(size_t n) { return (void*)(n); // Is it safe? } No, that is not guaranteed. Use intptr_t or uintptr_t to safely store a pointer in an integer. There are/were architectures where it makes sense for that to be false, such as the segmented DOS memory model. There the memory was structured in 64k segments - an object could never be larger than a segment, so 16-bit size_t would be enough. However, a pointer had "segment" and "offset" parts, so

I am working on a department website that needs to be standards compliant (xhtml 1.0 transitional), but embedded flash keeps breaking the validation. We use the <embed> tag because we need to support most major browsers. We can't use external tools, since the site is managed through a system and the admins don't like us putting extra tools (like JavaScript libraries etc) that could interfere with their template engine. How widely supported is the object tag? Is it safe to use only the <object> tag and remove the <embed> tag all together? <embed> is invalid in XHTML 1.0 and HTML 4, but it’s

I originally wrote some code like this: class Foo { public: Foo() : m_buffer() {} private: char m_buffer[1024]; }; Someone who is smarter than me said that having the m_buffer() initializer would zero out the memory. My intention was to leave the memory uninitialized. I didn't have time to discuss it further, but it piqued my curiosity. Previously, I had thought it was wise to always list each member in the initializer list. Could someone please describe this behavior further? 1) Why does the empty-paren initializer fill in memory? 2) Does it only hold for POD datatypes? I heard that it was so