database.cpp

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

	if (sattr2.fvalue == 0.0) {
	    iattr.removeTemporaries();
	    iattr.db->handleError(ArithmeticError, "Division by zero");
	} else {
	    sattr.fvalue /= sattr2.fvalue;
	}
	return;
      case dbvmAbsReal:
	execute(expr->operand[0], iattr, sattr);
	if (sattr.fvalue < 0) { 
	    sattr.fvalue = -sattr.fvalue;
	}
	return;
      case dbvmPowerReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if (sattr.fvalue < 0) { 
	    iattr.removeTemporaries();
	    iattr.db->handleError(ArithmeticError, 
				  "Power operator returns complex result");
	} else if (sattr.fvalue == 0.0 && sattr2.fvalue < 0) { 
	    iattr.removeTemporaries();
	    iattr.db->handleError(ArithmeticError, 
				  "Raise zero to negative power");	    
	} else { 
	    sattr.fvalue = pow(sattr.fvalue, sattr2.fvalue);
	}
	return;
      case dbvmPowerRealInt:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if (sattr.fvalue == 0.0 && sattr2.ivalue < 0) { 
	    iattr.removeTemporaries();
	    iattr.db->handleError(ArithmeticError, 
				  "Raise zero to negative power");	    
	} else { 
	    sattr.fvalue = powerRealInt(sattr.fvalue, sattr2.ivalue);
	}
	return;

      case dbvmEqReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.fvalue == sattr2.fvalue;
	return;
      case dbvmNeReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.fvalue != sattr2.fvalue;
	return;
      case dbvmGtReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.fvalue > sattr2.fvalue;
	return;
      case dbvmGeReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.fvalue >= sattr2.fvalue;
	return;
      case dbvmLtReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.fvalue < sattr2.fvalue;
	return;
      case dbvmLeReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.fvalue <= sattr2.fvalue;
	return;
      case dbvmBetweenReal:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if (sattr.fvalue < sattr2.fvalue) { 
	    sattr.bvalue = false;
	} else { 
	    execute(expr->operand[2], iattr, sattr2);
	    sattr.bvalue = sattr.fvalue <= sattr2.fvalue;
	}
	return;

     case dbvmEqBinary:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = (*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) == 0;
	return;
      case dbvmNeBinary:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = (*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) != 0;
	return;
      case dbvmGtBinary:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = (*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) > 0;
	return;
      case dbvmGeBinary:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = (*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) >= 0;
	return;
      case dbvmLtBinary:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = (*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) < 0;
	return;
      case dbvmLeBinary:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = (*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) <= 0;
	return;
      case dbvmBetweenBinary:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if ((*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) < 0) {
	    sattr.bvalue = false;
	} else {
	    execute(expr->operand[2], iattr, sattr2);
	    sattr.bvalue = (*(dbUDTComparator)expr->func.fptr)(sattr.raw, sattr2.raw, expr->offs) <= 0;
	}
	return;

      case dbvmIntToReal:
	execute(expr->operand[0], iattr, sattr);
	sattr.fvalue = (real8)sattr.ivalue;
	return;
      case dbvmRealToInt:
	execute(expr->operand[0], iattr, sattr);
	sattr.ivalue = (db_int8)sattr.fvalue;
	return;

      case dbvmIntToString:
	execute(expr->operand[0], iattr, sattr);
	convertIntToString(iattr, sattr);
	return;
      case dbvmRealToString:
	execute(expr->operand[0], iattr, sattr);
	convertRealToString(iattr, sattr);
	return;
      case dbvmStringConcat:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	concatenateStrings(iattr, sattr, sattr2);
	return;
      case dbvmUpperString:
	execute(expr->operand[0], iattr, sattr);
	uppercaseString(iattr, sattr);
	return;
      case dbvmLowerString:
	execute(expr->operand[0], iattr, sattr);
	lowercaseString(iattr, sattr);
	return;

      case dbvmEqString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = compareStrings(sattr, sattr2) == 0;
	return;
      case dbvmNeString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = compareStrings(sattr, sattr2) != 0;
	return;
      case dbvmGtString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = compareStrings(sattr, sattr2) > 0;
	return;
      case dbvmGeString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = compareStrings(sattr, sattr2) >= 0;
	return;
      case dbvmLtString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = compareStrings(sattr, sattr2) < 0;
	return;
      case dbvmLeString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = compareStrings(sattr, sattr2) <= 0;
	return;
      case dbvmLikeString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = matchStrings(sattr, sattr2);
	return;
      case dbvmLikeEscapeString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	execute(expr->operand[2], iattr, sattr3);
	sattr.bvalue = matchStrings(sattr, sattr2, *sattr3.array.base);
	return;
      case dbvmBetweenString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	if (compareStrings(sattr, sattr2) < 0) { 
	    sattr.bvalue = false;
	} else { 
	    execute(expr->operand[2], iattr, sattr2);
	    sattr.bvalue = compareStrings(sattr, sattr2) <= 0;
	}
	return;

      case dbvmEqBool:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.bvalue == sattr2.bvalue;
	return;
      case dbvmNeBool:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.bvalue != sattr2.bvalue;
	return;

      case dbvmEqReference:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.oid == sattr2.oid;
	return;
      case dbvmNeReference:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	sattr.bvalue = sattr.oid != sattr2.oid;
	return;

      case dbvmDeref:
	execute(expr->operand[0], iattr, sattr);
	if (sattr.oid == 0) { 
	    iattr.removeTemporaries();
	    iattr.db->handleError(NullReferenceError);
	}
	assert(!(iattr.db->currIndex[sattr.oid] 
		 & (dbInternalObjectMarker|dbFreeHandleMarker)));
	sattr.base = iattr.db->baseAddr + iattr.db->currIndex[sattr.oid];
	return;

      case dbvmFuncArg2Bool:
	sattr.bvalue = (*(bool(*)(dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0));
	return;
      case dbvmFuncArg2Int:
	sattr.ivalue = (*(db_int8(*)(dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0));
	return;
      case dbvmFuncArg2Real:
	sattr.fvalue = (*(real8(*)(dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0));
	return;
      case dbvmFuncArg2Str:
	copyString(iattr, sattr, 
		   (*(char*(*)(dbUserFunctionArgument const&))expr->func.fptr)
		   (dbUserFunctionArgument(expr, iattr, sattr, 0)));
	return;
      case dbvmFuncArgArg2Bool:
	sattr.bvalue = (*(bool(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0), 
	     dbUserFunctionArgument(expr, iattr, sattr, 1));
	return;
      case dbvmFuncArgArg2Int:
	sattr.ivalue = (*(db_int8(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0), 
	     dbUserFunctionArgument(expr, iattr, sattr, 1));
	return;
      case dbvmFuncArgArg2Real:
	sattr.fvalue = (*(real8(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0), 
	     dbUserFunctionArgument(expr, iattr, sattr, 1));
	return;
      case dbvmFuncArgArg2Str:
	copyString(iattr, sattr, 
		   (*(char*(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
		   (dbUserFunctionArgument(expr, iattr, sattr, 0),
		    dbUserFunctionArgument(expr, iattr, sattr, 1)));
	return;
      case dbvmFuncArgArgArg2Bool:
	sattr.bvalue = (*(bool(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0),
	     dbUserFunctionArgument(expr, iattr, sattr, 1), 
	     dbUserFunctionArgument(expr, iattr, sattr, 2));
	return;
      case dbvmFuncArgArgArg2Int:
	sattr.ivalue = (*(db_int8(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0), 
	     dbUserFunctionArgument(expr, iattr, sattr, 1), 
	     dbUserFunctionArgument(expr, iattr, sattr, 2));
	return;
      case dbvmFuncArgArgArg2Real:
	sattr.fvalue = (*(real8(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
	    (dbUserFunctionArgument(expr, iattr, sattr, 0), 
	     dbUserFunctionArgument(expr, iattr, sattr, 1),
	     dbUserFunctionArgument(expr, iattr, sattr, 2));
	return;
      case dbvmFuncArgArgArg2Str:
	copyString(iattr, sattr, 
		   (*(char*(*)(dbUserFunctionArgument const&, dbUserFunctionArgument const&, dbUserFunctionArgument const&))expr->func.fptr)
		   (dbUserFunctionArgument(expr, iattr, sattr, 0), 
		    dbUserFunctionArgument(expr, iattr, sattr, 1), 
		    dbUserFunctionArgument(expr, iattr, sattr, 2)));
	return;



      case dbvmFuncInt2Bool:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.bvalue = (*(bool(*)(db_int8))expr->func.fptr)(sattr.ivalue);
	return;
      case dbvmFuncReal2Bool:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.bvalue = (*(bool(*)(real8))expr->func.fptr)(sattr.fvalue);
	return;
      case dbvmFuncStr2Bool:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.bvalue = 
	    (*(bool(*)(char const*))expr->func.fptr)(sattr.array.base);
	return;
      case dbvmFuncInt2Int:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.ivalue = (*(db_int8(*)(db_int8))expr->func.fptr)(sattr.ivalue);
	return;
      case dbvmFuncReal2Int:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.ivalue = (*(db_int8(*)(real8))expr->func.fptr)(sattr.fvalue);
	return;
      case dbvmFuncStr2Int:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.ivalue = 
	    (*(db_int8(*)(char const*))expr->func.fptr)(sattr.array.base);
	return;
      case dbvmFuncInt2Real:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.fvalue = (*(real8(*)(db_int8))expr->func.fptr)(sattr.ivalue);
	return;
      case dbvmFuncReal2Real:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.fvalue = (*(real8(*)(real8))expr->func.fptr)(sattr.fvalue);
	return;
      case dbvmFuncStr2Real:
	execute(expr->func.arg[0], iattr, sattr);
	sattr.fvalue = 
	    (*(real8(*)(char const*))expr->func.fptr)(sattr.array.base);
	return;
      case dbvmFuncInt2Str:
	execute(expr->func.arg[0], iattr, sattr);
	copyString(iattr, sattr, 
		   (*(char*(*)(db_int8))expr->func.fptr)(sattr.ivalue));
	return;
      case dbvmFuncReal2Str:
	execute(expr->func.arg[0], iattr, sattr);
	copyString(iattr, sattr, 
		   (*(char*(*)(real8))expr->func.fptr)(sattr.fvalue));
	return;
      case dbvmFuncStr2Str:
	execute(expr->func.arg[0], iattr, sattr);
	copyString(iattr, sattr, 
		  (*(char*(*)(char const*))expr->func.fptr)(sattr.array.base));
	return;

      case dbvmInArrayBool:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfBool(sattr, sattr2);
	return;
      case dbvmInArrayInt1:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfInt1(sattr, sattr2);
	return;
      case dbvmInArrayInt2:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfInt2(sattr, sattr2);
	return;
      case dbvmInArrayInt4:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfInt4(sattr, sattr2);
	return;
      case dbvmInArrayInt8:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfInt8(sattr, sattr2);
	return;
      case dbvmInArrayReal4:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfReal4(sattr, sattr2);
	return;
      case dbvmInArrayReal8:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfReal8(sattr, sattr2);
	return;
      case dbvmInArrayString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfString(sattr, sattr2);
	return;
      case dbvmInArrayReference:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchArrayOfReference(sattr, sattr2);
	return;
      case dbvmInString:
	execute(expr->operand[0], iattr, sattr);
	execute(expr->operand[1], iattr, sattr2);
	searchInString(sattr, sattr2);
	return;

      default:
	assert(false);
    }
}


void dbDatabase::handleError(dbErrorClass error, char const* msg, int arg)
{
    if (errorHandler != NULL) { 
        (*errorHandler)(error, msg, arg);
    }
#ifdef THROW_EXCEPTION_ON_ERROR
    if (error != NoError) {
	throw dbException(error, msg, arg);
    }
#else
    char buf[256];
    switch (error) { 
      case QueryError:
	fprintf(stderr, "%s in position %d\n", msg, arg);
	return;
      case ArithmeticError:
	fprintf(stderr, "%s\n", msg);
	break;