• Firebird
• Interbase
• MS SQL Server
• MySQL
• Oracle
• PostgreSQL
• SQLite
• SQLite3
• Sybase

typedef int (*pifi)(int);
pifi      nfibs = (pifi) (jit_set_ip(codeBuffer).iptr);
int        in;                /**//* offset of the argument */
jit_insn  *ref;            /**//* to patch the forward reference */
            jit_prolog   (1);
in =  jit_arg_ui   ();
            jit_getarg_ui(JIT_V0, in);              /**//* V0 = n */
ref = jit_blti_ui  (jit_forward(), JIT_V0, 2);
            jit_subi_ui  (JIT_V1, JIT_V0, 1);       /**//* V1 = n-1 */
            jit_subi_ui  (JIT_V2, JIT_V0, 2);       /**//* V2 = n-2 */
            jit_prepare_i(1);
            jit_pusharg_ui(JIT_V1);
            jit_finish(nfibs);
            jit_retval_i (JIT_V1);                   /**//* V1 = nfibs(n-1) */
            jit_prepare_i(1);
            jit_pusharg_ui(JIT_V2);
            jit_finish(nfibs);
            jit_retval_i (JIT_V2);                   /**//* V2 = nfibs(n-2) */
            jit_addi_ui(JIT_V1,  JIT_V1,  1);
            jit_addr_ui(JIT_RET, JIT_V1, JIT_V2);   /**//* RET = V1 + V2 + 1 */
            jit_ret();
jit_patch(ref);                               /**//* patch jump */
            jit_movi_i(JIT_RET, 1);                 /**//* RET = 1 */
            jit_ret();
/**//* call the generated code, passing 32 as an argument */
jit_flush_code(codeBuffer, jit_get_ip().ptr);

froofyJIT:

typedef int (*pifi)(int);
pifi nfibs;
int in;
{
        using namespace froofy::jit;
        label<> basis;

nfibs/  !org,           codeBuffer;
        prolog,         1, 0, false;
        !arg<ui>        in;
        getarg<ui>      v0, in;
        blti<ui>        basis, v0, 2;
        subi<ui>        v1, v0, 1;
        subi<ui>        v2, v0, 2;
        prepare<i>      1;
        pusharg<ui>     v1;
        finish,         nfibs;
        retval<i>       v1;
        prepare<i>      1;
        pusharg<ui>     v2;
        finish,         nfibs;
        retval<i>       v2;
        addi<ui>        v1, v1, 1;
        addr<ui>        rr, v1, v2;
        ret,            1, 0, false;
basis/  movi<i>         rr, 1;
        ret,            1, 0, false;
        !end,           codeBuffer;
}

1、&的转义
    以前一直都不知道，原来在SQLPlus中，&的含义是让用户输入参数。
例如：insert into my_table values('0=0&1=0&2=0');
执行SQLPlus的时候，就会提示：
Enter value for 1: abc
Enter value for 2: efg
然后实际插入的结果是：
insert into my_table values('0=0abc=0efg=0');
    要去掉这个功能有两种实现方法：
    A、用转义字符：在QQ群友e点的帮助下，找到下面这段话：
SQLPLUS recognizes the '&' "and" character as a substitution character for data input.
So to store a string such as "Johnson & Son" into an Oracle table, use an escape character, as in 'Johnson \& Son' (with the \&).

But first turn on escape character processing:

SQL> set escape \ 

    B、更简单，关闭这个功能就行了：
SET DEFINE OFF;
Use SET DEFINE OFF to prevent scanning for the substitution character. Reference: bug 13199

2、md5
    其实应该不算是奇怪问题，由于shell scrip调用的一批初始化数据库数据的SQL语句想在mysql和Oracle之间通用，即不想mysql中管理一份，oracle中管理一份。其实语句大部分都是相同，但唯独有个初始化管理员密码的SQL语句碰上麻烦。密码是md5加密的，插入mysql的时候可以使用mysql的md5函数，但是Oracle没有同名的函数。网上google一把，很多解决方案，但试了几个都不行。后来综合了几个的做法，最终得出一个结果：
CREATE OR REPLACE FUNCTION md5(passwd IN VARCHAR2) RETURN VARCHAR2
IS
 retval varchar2(32);
BEGIN
 retval := lower( utl_raw.cast_to_raw(DBMS_OBFUSCATION_TOOLKIT.MD5(INPUT_STRING => passwd)) );
 RETURN retval;
END;

近来公司其中一个项目需要程序在g++ 3.4.3下编译，而源代码在g++ 3.2.3下面一个Warning都没有，但是在3.4.3下则一堆Error了。后来发现原来g++ 3.4.3严格了很多。其中“出问题”最多的是这种情况：

class TObjBase
{
public:
    TObjBase(void) : m_nVal(0) {}
    ~TObjBase(void) {}

    int getVal(void) const { return m_nVal; }
    void setVal(int n) { m_nVal = n; }
protected:
    int    m_nVal;
};

template<class typeObj>
class TExtObj : public typeObj
{
public:
    TExtObj(void) : typeObj() {}

    int getExtVal(void) const { return getVal() + 100; }
};

这是一种比较常见的应用，Adapter和Decorator模式都会用到这种技术。但问题在于g++ 3.4.3却说int getExtVal(void) const { return getVal() + 100; }这一行错误，getVal()找不到。

的确，单以TExtObj这个类看来，怎么也是找不到getVal()的定义在哪里。g++ 3.2.3以及VC6、VC7等，均以十分相信开发者的态度猜测这个函数必定在其他地方定义了，有可能是外部独立的函数、有可能是typeObj的成员函数。但g++ 3.4.3却非要程序员很负责任的告诉编译器，究竟是哪一个getVal()，于是解决方法：
方法一：
int getExtVal(void) const { return typeObj::getVal() + 100; }

或者

方法二：
int getExtVal(void) const { return this->getVal() + 100; }

当然，如果是外部的独立函数，那就是：

int getExtVal(void) const { return ::getVal() + 100; }

然而，在getVal()是虚函数的时候，方法一和方法二是有区别的，这个是需要十分小心的事情。方法一是无论什么时候都会调用typeObj的getVal()，方法二是调用当前类最适合的虚函数getVal()。

void  TMyClass::onLoad(TStorage & s)
{
    s >> member1;
    s >> member2;
      ......
}
假如s满了（Save的时候）或者s数据不足（Load的时候），函数会等待，直到s可用或者出错退出。相当于进程的Stack帮我们保存了I/O状态的上下文。

但是现在要转到异步方式I/O，当s“不可用”的时候，线程应该中断当前的操作，把I/O状态的上下文保存下来，转而做其他的操作。
所以麻烦就来了，要自己做这个上下文的保存。一般来说要记录以下的内容：

1、操作到哪一个成员。
2、假如成员是一个普通的类型、那就要记录操作到类型的哪一个byte。
2、如果成员是一个复合类型，同样，递归地回到了1。

因此，上下文保存的结果一般都是一个自己做的stack，里面就是记录这个递归的过程。

其实想想，何苦为了省那几十k的空间折磨自己呢，例如输出，先用同步的方式把数据记录在内存，然后就记录内存的起始地址和长度，异步处理的时候就把内存输出，如果没有输出完的，就记下未输出部分的起始地址和长度，等待下一次。
不过当结果比较庞大的时候，还是需要自己慢慢苦干，真是悲惨……