Group items tagged

The problem is that generics don't get on with arrays. The solution is obvious: ditch arrays. From a practical point of view, there's not a great deal of point in returning arrays from methods instead of collections of s

Note the circular reference in "Unique<T extends Unique>" It means that the implementing class needs to provide another unique class as the namespace for it's Id's. The really freaky thing is that it can provide itself. :) These two interfaces enable a way to describe uniquely identified objects with heirarchical namespaces in a typesafe manner. How much complex code did that save?

ype". You only need generics in strictly typed function dispatch languages like C++ and Java. You don't need them in message passing dynamically typed languages like Smalltalk and Objective C. To work around the first rule - "strict static typing doesn't really work all the time", we get hacks like templates and generics

call the Elvis/Einstein b

uses non-deterministic functions such as UUID(), RAND(), CONNECTION_ID() etc it will not be cached.

If table gets modification all queries derived from this table are invalidated at once

if you have high write application such as forums, query cache efficiency might be pretty low due to this.

all queries are removed from cache on table modifications - if there are a lot of queries being cached this might reduce update speed a bit

Qcache_free_memory and Qcache_lowmem_prunes

number of your selects - Com_select and see how many of them are cached. Query Cache efficiency would be Qcache_hits/(Com_select+Qcache_hits).

One portion of query cache overhead is of course inserts so you can see how much of inserted queries are used: Qcache_hits/Qcache_inserts Other portion of overhead comes from modification statements which you can calculate by (Com_insert+Com_delete+Com_update+Com_replace)/Qcache_hits

want to set query cache

means it is much more efficient as query which required processing millions of rows now can be instantly summoned from query cache

It also means query has to be exactly the same and deterministic, so hit rate would generally be less

full page caching

not using query_cache_wlock_invalidate=ON locking table for write would not invalidate query cache so you can get results evenif table is locked and is being prepared to be updated

it can serve responses very fast doing no extra conversion or processing.

but it is still not as fast as specially designed systems such as memcached or local shared memory.

It is not distributed If you have 10 slaves and use query cache on all of them cache content will likely be the same, so you have multiple copies of the same data in cache effectively wasting memory

What's the point in designing tables for a webapp when an RDF-backed store will manage the data for you and RDF queries will come back as tabular data anyway?

designing and maintaining yet another relational schema for yet another webapp - doing so is starting to make as much sense as designing my own filesystem or TP monitor.

RDF + SPARQL + distributed data sources from around the web?

reason that rails and django are so productive; they're highly optimised for domain models. Raw RDF doesn't really do domains like that; you have to expend effort distilling triples into 'things';