database.cpp

来自「FastDb是高效的内存数据库系统」· C++ 代码 · 共 2,469 行 · 第 1/5 页

    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);

    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 dbvmIntToReference:
    execute(expr->operand[0], iattr, sattr);
    sattr.oid = (oid_t)sattr.ivalue;
    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;