database.cpp

一个功能强大的内存数据库源代码,c++编写,有详细的注释

	execute(expr->operand[0], iattr, sattr);
	sattr.bvalue = *(bool*)(sattr.base+expr->offs);
	return;
      case dbvmLoadInt1:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = *(int1*)(sattr.base+expr->offs);
	return;
      case dbvmLoadInt2:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = *(int2*)(sattr.base+expr->offs);
	return;
      case dbvmLoadInt4:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = *(int4*)(sattr.base+expr->offs);
	return;
      case dbvmLoadInt8:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = *(db_int8*)(sattr.base+expr->offs);
	return;
      case dbvmLoadReal4:
	execute(expr->operand[0], iattr, sattr);
	sattr.fvalue = *(real4*)(sattr.base+expr->offs);
	return;
      case dbvmLoadReal8:
	execute(expr->operand[0], iattr, sattr);
	sattr.fvalue = *(real8*)(sattr.base+expr->offs);
	return;
      case dbvmLoadReference:
	execute(expr->operand[0], iattr, sattr);
	sattr.oid = *(oid_t*)(sattr.base+expr->offs);
	return;
      case dbvmLoadArray:
      case dbvmLoadString:
	execute(expr->operand[0], iattr, sattr2);
	sattr.array.base = (char*)sattr2.base 
	    + ((dbVarying*)(sattr2.base + expr->offs))->offs;
	sattr.array.size = ((dbVarying*)(sattr2.base + expr->offs))->size;
	return;
      case dbvmLoadRawBinary:
	execute(expr->operand[0], iattr, sattr);
	sattr.raw = (void*)(sattr.base+expr->offs);
	return;

      case dbvmLoadSelfBool:
	sattr.bvalue = *(bool*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfInt1:
	sattr.ivalue = *(int1*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfInt2:
	sattr.ivalue = *(int2*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfInt4:
	sattr.ivalue = *(int4*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfInt8:
	sattr.ivalue = *(db_int8*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfReal4:
	sattr.fvalue = *(real4*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfReal8:
	sattr.fvalue = *(real8*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfReference:
	sattr.oid = *(oid_t*)(iattr.record+expr->offs);
	return;
      case dbvmLoadSelfArray:
      case dbvmLoadSelfString:
	sattr.array.base = (char*)iattr.record + 
	    ((dbVarying*)(iattr.record + expr->offs))->offs;
	sattr.array.size = ((dbVarying*)(iattr.record + expr->offs))->size;
	return;
      case dbvmLoadSelfRawBinary:
	sattr.raw = (void*)(iattr.record+expr->offs);
	return;

      case dbvmInvokeMethodBool:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr.bvalue);
	sattr.bvalue = *(bool*)&sattr.bvalue;
	return;
      case dbvmInvokeMethodInt1:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr.ivalue);
	sattr.ivalue = *(int1*)&sattr.ivalue;
	return;
      case dbvmInvokeMethodInt2:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr.ivalue);
	sattr.ivalue = *(int2*)&sattr.ivalue;
	return;
      case dbvmInvokeMethodInt4:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr.ivalue);
	sattr.ivalue = *(int4*)&sattr.ivalue;
	return;
      case dbvmInvokeMethodInt8:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr.ivalue);
	return;
      case dbvmInvokeMethodReal4:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr.fvalue); 
	sattr.fvalue = *(real4*)&sattr.fvalue;
	return;
      case dbvmInvokeMethodReal8:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr.fvalue);
	return;
      case dbvmInvokeMethodReference:
	execute(expr->ref.base, iattr, sattr);
        expr->ref.field->method->invoke(sattr.base, &sattr.oid);
	return;
      case dbvmInvokeMethodString:
	execute(expr->ref.base, iattr, sattr);
	expr->ref.field->method->invoke(sattr.base, &sattr2.array.base);
	sattr.array.size = strlen(sattr2.array.base) + 1;
	sattr.array.base = dbStringValue::create(sattr2.array.base, iattr);
	delete[] sattr2.array.base;
	return;

      case dbvmInvokeSelfMethodBool:
	expr->ref.field->method->invoke(iattr.record, &sattr.bvalue);
	sattr.bvalue = *(bool*)&sattr.bvalue;
	return;
      case dbvmInvokeSelfMethodInt1:
	expr->ref.field->method->invoke(iattr.record, &sattr.ivalue);
	sattr.ivalue = *(int1*)&sattr.ivalue;
	return;
      case dbvmInvokeSelfMethodInt2:
	expr->ref.field->method->invoke(iattr.record, &sattr.ivalue);
	sattr.ivalue = *(int2*)&sattr.ivalue;
	return;
      case dbvmInvokeSelfMethodInt4:
	expr->ref.field->method->invoke(iattr.record, &sattr.ivalue);
	sattr.ivalue = *(int4*)&sattr.ivalue;
	return;
      case dbvmInvokeSelfMethodInt8:
	expr->ref.field->method->invoke(iattr.record, &sattr.ivalue);
	return;
      case dbvmInvokeSelfMethodReal4:
	expr->ref.field->method->invoke(iattr.record, &sattr.fvalue); 
	sattr.fvalue = *(real4*)&sattr.fvalue;
	return;
      case dbvmInvokeSelfMethodReal8:
	expr->ref.field->method->invoke(iattr.record, &sattr.fvalue);
	return;
      case dbvmInvokeSelfMethodReference:
	expr->ref.field->method->invoke(iattr.record, &sattr.oid);
	return;
      case dbvmInvokeSelfMethodString:
	expr->ref.field->method->invoke(iattr.record, &sattr2.array.base);
	sattr.array.size = strlen(sattr2.array.base) + 1;
	sattr.array.base = dbStringValue::create(sattr2.array.base, iattr);
	delete[] sattr2.array.base;
	return;

      case dbvmLength:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = sattr.array.size;
	return;
      case dbvmStringLength:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = sattr.array.size - 1;
	return;

      case dbvmGetAt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if ((nat8)sattr2.ivalue >= (nat8)sattr.array.size) { 
	    if (expr->operand[1]->cop == dbvmVariable) { 
		longjmp(iattr.exists_iterator[expr->operand[1]->offs].unwind, 1);
	    }
	    iattr.removeTemporaries();
	    iattr.db->handleError(IndexOutOfRangeError, NULL, 
				  int(sattr2.ivalue));
	}
	sattr.base = (byte*)sattr.array.base + int(sattr2.ivalue)*expr->offs;
	return;
      case dbvmCharAt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if ((nat8)sattr2.ivalue >= (nat8)(sattr.array.size-1)) { 
	    if (expr->operand[1]->cop == dbvmVariable) { 
		longjmp(iattr.exists_iterator[expr->operand[1]->offs].unwind, 1);
	    }
	    iattr.removeTemporaries();
	    iattr.db->handleError(IndexOutOfRangeError, NULL, 
				  int(sattr2.ivalue));
	}
	sattr.ivalue = (byte)sattr.array.base[int(sattr2.ivalue)];
	return;

      case dbvmExists:
	iattr.exists_iterator[expr->offs].index = 0;
	if (setjmp(iattr.exists_iterator[expr->offs].unwind) == 0) { 
	    do { 
		execute(expr->operand[0], iattr, sattr);
		iattr.exists_iterator[expr->offs].index += 1;
	    } while (!sattr.bvalue);
	} else {
	    sattr.bvalue = false;
	}
	return;

      case dbvmVariable:
	sattr.ivalue = iattr.exists_iterator[expr->offs].index;
	return;

      case dbvmLoadVarBool:
	sattr.bvalue = *(bool*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarInt1:
	sattr.ivalue = *(int1*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarInt2:
	sattr.ivalue = *(int2*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarInt4:
	sattr.ivalue = *(int4*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarInt8:
	sattr.ivalue = *(db_int8*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarReal4:
	sattr.fvalue = *(real4*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarReal8:
	sattr.fvalue = *(real8*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarReference:
	sattr.oid = *(oid_t*)((char*)expr->var + iattr.paramBase);
	return;
      case dbvmLoadVarString:
	sattr.array.base = (char*)((char*)expr->var + iattr.paramBase);
	sattr.array.size = strlen((char*)sattr.array.base) + 1;
	return;
      case dbvmLoadVarStringPtr:
	sattr.array.base = *(char**)((char*)expr->var + iattr.paramBase);
	sattr.array.size = strlen((char*)sattr.array.base) + 1;
	return;
      case dbvmLoadVarArray:
	sattr.array.base = (char*)((dbAnyArray*)((char*)expr->var + iattr.paramBase))->base();
	sattr.array.size = ((dbAnyArray*)((char*)expr->var + iattr.paramBase))->length();
	return;
      case dbvmLoadVarArrayPtr:
	{
	    dbAnyArray* arr = *(dbAnyArray**)((char*)expr->var + iattr.paramBase);
	    sattr.array.base = (char*)arr->base();
	    sattr.array.size = arr->length();
	    return;
	}
      case dbvmLoadVarRawBinary:
	sattr.raw = (void*)((char*)expr->var + iattr.paramBase);
	return;

#ifdef USE_STD_STRING
      case dbvmLoadVarStdString:
	sattr.array.base = (char*)((std::string*)((char*)expr->var + iattr.paramBase))->c_str();
	sattr.array.size = ((std::string*)((char*)expr->var + iattr.paramBase))->length() + 1;
	return;
#endif

      case dbvmLoadTrue:
	sattr.bvalue = true;
	return;
      case dbvmLoadFalse:
	sattr.bvalue = false;
	return;
      case dbvmLoadNull:
	sattr.oid = 0;
	return;
      case dbvmLoadIntConstant:
	sattr.ivalue = expr->ivalue;
	return;
      case dbvmLoadRealConstant:
	sattr.fvalue = expr->fvalue;
	return;
      case dbvmLoadStringConstant:
	sattr.array.base = expr->svalue.str;
	sattr.array.size = expr->svalue.len;
	return;
    
      case dbvmOrBool:
	execute(expr->operand[0], iattr, sattr);
	if (sattr.bvalue == 0) { 
	    execute(expr->operand[1], iattr, sattr);
	}
	return;
      case dbvmAndBool:
	execute(expr->operand[0], iattr, sattr);
	if (sattr.bvalue != 0) { 
	    execute(expr->operand[1], iattr, sattr);
	}
	return;
      case dbvmNotBool:
	execute(expr->operand[0], iattr, sattr);
	sattr.bvalue = !sattr.bvalue; 
	return;

      case dbvmIsNull:
	execute(expr->operand[0], iattr, sattr);
	sattr.bvalue = sattr.oid == 0;
	return;

      case dbvmNegInt:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = -sattr.ivalue;
	return;
      case dbvmAddInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.ivalue += sattr2.ivalue;
	return;
      case dbvmSubInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.ivalue -= sattr2.ivalue;
	return;
      case dbvmMulInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.ivalue *= sattr2.ivalue;
	return;
      case dbvmDivInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if (sattr2.ivalue == 0) { 
	    iattr.removeTemporaries();
	    iattr.db->handleError(ArithmeticError, "Division by zero");
	} else { 
	    sattr.ivalue /= sattr2.ivalue;
	}
	return;
      case dbvmAndInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.ivalue &= sattr2.ivalue;
	return;
      case dbvmOrInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.ivalue |= sattr2.ivalue;
	return;
      case dbvmNotInt:
	execute(expr->operand[0], iattr, sattr);
        sattr.ivalue = ~sattr.ivalue;
	return;
      case dbvmAbsInt:
	execute(expr->operand[0], iattr, sattr);
	if (sattr.ivalue < 0) { 
	    sattr.ivalue = -sattr.ivalue;
	}
	return;
      case dbvmPowerInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if (sattr.ivalue == 2) { 
	    sattr.ivalue = sattr2.ivalue < 64 
		? (nat8)1 << (int)sattr2.ivalue : 0;
	} else if (sattr.ivalue == 0 && sattr2.ivalue < 0) { 
	    iattr.removeTemporaries();
	    iattr.db->handleError(ArithmeticError, 
				  "Raise zero to negative power");	    
	} else { 
	    sattr.ivalue = powerIntInt(sattr.ivalue, sattr2.ivalue);
	}
	return;

	
      case dbvmEqInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.ivalue == sattr2.ivalue;
	return;
      case dbvmNeInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.ivalue != sattr2.ivalue;
	return;
      case dbvmGtInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.ivalue > sattr2.ivalue;
	return;
      case dbvmGeInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.ivalue >= sattr2.ivalue;
	return;
      case dbvmLtInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.ivalue < sattr2.ivalue;
	return;
      case dbvmLeInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.ivalue <= sattr2.ivalue;
	return;
      case dbvmBetweenInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if (sattr.ivalue < sattr2.ivalue) { 
	    sattr.bvalue = false;
	} else { 
	    execute(expr->operand[2], iattr, sattr2);
	    sattr.bvalue = sattr.ivalue <= sattr2.ivalue;
	}
	return;

      case dbvmNegReal:
	execute(expr->operand[0], iattr, sattr);
	sattr.fvalue = -sattr.fvalue;
	return;
      case dbvmAddReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.fvalue += sattr2.fvalue;
	return;
      case dbvmSubReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.fvalue -= sattr2.fvalue;
	return;
      case dbvmMulReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.fvalue *= sattr2.fvalue;
	return;
      case dbvmDivReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);