server.cpp

FastDb是高效的内存数据库系统

          len = cb->len;
          break;
        }
      }

      offs = DOALIGN(offs, fd->components->alignment)
             + len*fd->components->dbsSize;
    }
  }
  while ((fd = fd->next) != first);

  old_data = new char[rec->size];

  memcpy(old_data, rec, rec->size);

  for (cb = stmt->columns; cb != NULL; cb = cb->next)
  {
    if (cb->fd->attr & dbFieldDescriptor::Updated)
    {
      if (cb->fd->indexType & HASHED)
      {

        dbHashTable::remove
          (db, cb->fd->hashTable,
           stmt->cursor->currId,
           cb->fd->type, cb->fd->dbsSize, cb->fd->dbsOffs);
      }

      if (cb->fd->indexType & INDEXED)
      {

        dbTtree::remove
          (db, cb->fd->tTree, stmt->cursor->currId,
           cb->fd->type, cb->fd->dbsSize, cb->fd->comparator, cb->fd->dbsOffs);
      }
    }
  }

  db->modified = true;
  new_data = (char*)db->putRow(stmt->cursor->currId, offs);

  fd = first;
  offs = table->fixedSize;

  do
  {
    if (fd->type == dbField::tpArray|| fd->type == dbField::tpString)
    {
      int len = ((dbVarying*)(old_data + fd->dbsOffs))->size;
      offs = DOALIGN(offs, fd->components->alignment);

      for (cb = stmt->columns; cb != NULL; cb = cb->next)
      {
        if (cb->fd == fd)
        {
          len = cb->unpackArray(new_data, offs);
          break;
        }
      }

      if (cb == NULL)
      {
        memcpy(new_data + offs,
               old_data + ((dbVarying*)(old_data + fd->dbsOffs))->offs,
               len*fd->components->dbsSize);
      }

      ((dbVarying*)(new_data + fd->dbsOffs))->size = len;
      ((dbVarying*)(new_data + fd->dbsOffs))->offs = offs;
      offs += len*fd->components->dbsSize;
    }
    else
    {

      for (cb = stmt->columns; cb != NULL; cb = cb->next)
      {
        if (cb->fd == fd)
        {
          cb->unpackScalar(new_data);
          break;
        }
      }

      if (cb == NULL)
      {
        memcpy(new_data + fd->dbsOffs, old_data + fd->dbsOffs,
               fd->dbsSize);
      }
    }
  }
  while ((fd = fd->next) != first);

  delete[] old_data;

  for (cb = stmt->columns; cb != NULL; cb = cb->next)
  {
    if (cb->fd->attr & dbFieldDescriptor::Updated)
    {
      cb->fd->attr &= ~dbFieldDescriptor::Updated;

      if (cb->fd->indexType & HASHED)
      {
        dbHashTable::insert(db, cb->fd->hashTable,
                            stmt->cursor->currId,
                            cb->fd->type, cb->fd->dbsSize, cb->fd->dbsOffs, 0);
      }

      if (cb->fd->indexType & INDEXED)
      {
        dbTtree::insert(db, cb->fd->tTree, stmt->cursor->currId,
                        cb->fd->type, cb->fd->dbsSize, cb->fd->comparator, cb->fd->dbsOffs);
      }
    }
  }

  response = cli_ok;
  pack4(response);
  return session->sock->write(&response, sizeof response);
}



char* dbServer::checkColumns(dbStatement* stmt, int n_columns,
                             dbTableDescriptor* desc, char* data,
                             int4& response)
{
  dbColumnBinding** cpp = &stmt->columns;
  response = cli_ok;

  while (--n_columns >= 0)
  {
    int cliType = *data++;
    char* columnName = data;

    dbSymbolTable::add
      (columnName, tkn_ident, true);

    dbFieldDescriptor* fd = desc->findSymbol(columnName);

    data += strlen(data) + 1;

    if (fd != NULL)
    {
      if ((cliType == cli_oid
           && fd->type == dbField::tpReference)
          || (cliType >= cli_bool && cliType <= cli_int8
              && fd->type >= dbField::tpBool
              && fd->type <= dbField::tpInt8)
          || (cliType >= cli_real4 && cliType <= cli_real8
              && fd->type >= dbField::tpReal4
              && fd->type <= dbField::tpReal8)
          || ((cliType == cli_asciiz || cliType == cli_pasciiz)
              && fd->type == dbField::tpString)
          || (cliType == cli_array_of_oid &&
              fd->type == dbField::tpArray &&
              fd->components->type == dbField::tpReference)
          || (cliType >= cli_array_of_bool
              && fd->type  == dbField::tpArray
              && cliType-cli_array_of_bool
              == fd->components->type-dbField::tpBool))
      {
        dbColumnBinding* cb = new dbColumnBinding(fd, cliType);
        *cpp = cb;
        cpp = &cb->next;
      }
      else
      {
        response = cli_incompatible_type;
        break;
      }
    }
    else
    {
      TRACE_MSG(("Field '%s' not found\n", columnName));
      response = cli_column_not_found;
      break;
    }
  }

  return data;
}


bool dbServer::insert(dbSession* session, int stmt_id, char* data, bool prepare)
{
  dbStatement* stmt = findStatement(session, stmt_id);
  dbTableDescriptor* desc = NULL;
  dbColumnBinding* cb;
  int4   response;
  char   reply_buf[sizeof(cli_oid_t) + 8];
  char*  dst;
  oid_t  oid = 0;
  size_t offs;
  int    n_columns;

  if (stmt == NULL)
  {
    if (!prepare)
    {
      response = cli_bad_statement;
      goto return_response;
    }

    stmt = new dbStatement(stmt_id);
    stmt->next = session->stmts;
    session->stmts = stmt;
  }
  else
  {
    if (prepare)
    {
      stmt->reset();
    }
    else if ((desc = stmt->table) == NULL)
    {
      response = cli_bad_descriptor;
      goto return_response;
    }
  }

  if (prepare)
  {
    session->scanner.reset(data);

    if (session->scanner.get() != tkn_insert
        || session->scanner.get() != tkn_into
        || session->scanner.get() != tkn_ident)
    {
      response = cli_bad_statement;
      goto return_response;
    }

    desc = db->findTable(session->scanner.ident);

    if (desc == NULL)
    {
      response = cli_table_not_found;
      goto return_response;
    }

    data += strlen(data)+1;
    n_columns = *data++;
    data = checkColumns(stmt, n_columns, desc, data, response);

    if (response != cli_ok)
    {
      goto return_response;
    }

    stmt->table = desc;
  }

  offs = desc->fixedSize;

  for (cb = stmt->columns; cb != NULL; cb = cb->next)
  {
    cb->ptr = data;

    if (cb->cliType == cli_autoincrement)
    {
      ;
    }
    else if (cb->cliType >= cli_asciiz)
    {
      cb->len = unpack4(data);
      data += 4 + cb->len*cb->fd->components->dbsSize;
      offs = DOALIGN(offs, cb->fd->components->alignment)
             + cb->len*cb->fd->components->dbsSize;
    }
    else
    {
      data += sizeof_type[cb->cliType];
    }
  }

  db->beginTransaction(dbDatabase::dbExclusiveLock);
  db->modified = true;
  oid = db->allocateRow(desc->tableId, offs);
  dst = (char*)db->getRow(oid);

  offs = desc->fixedSize;

  for (cb = stmt->columns; cb != NULL; cb = cb->next)
  {
    dbFieldDescriptor* fd = cb->fd;

    if (fd->type == dbField::tpArray || fd->type == dbField::tpString)
    {
      offs = DOALIGN(offs, fd->components->alignment);
      ((dbVarying*)(dst + fd->dbsOffs))->offs = offs;
      ((dbVarying*)(dst + fd->dbsOffs))->size = cb->len;
      offs += cb->unpackArray(dst, offs)*fd->components->dbsSize;
    }
    else
    {
      cb->unpackScalar(dst);
    }
  }

  for (cb = stmt->columns; cb != NULL; cb = cb->next)
  {
    if (cb->fd->indexType & HASHED)
    {
      dbHashTable::insert(db, cb->fd->hashTable, oid,
                          cb->fd->type, cb->fd->dbsSize, cb->fd->dbsOffs, 0);
    }

    if (cb->fd->indexType & INDEXED)
    {
      dbTtree::insert(db, cb->fd->tTree, oid,
                      cb->fd->type, cb->fd->dbsSize, cb->fd->comparator, cb->fd->dbsOffs);
    }
  }

  response = cli_ok;

return_response:
        pack4(reply_buf, response);

  if (desc == NULL)
  {
    pack4(reply_buf+4, 0);
  }
  else
  {
#ifdef AUTOINCREMENT_SUPPORT
    pack4(reply_buf+4, desc->autoincrementCount);
#else

    pack4(reply_buf+4, ((dbTable*)db->getRow(desc->tableId))->nRows);
#endif

  }

  pack_oid(reply_buf+8, oid);
  return session->sock->write(reply_buf, sizeof reply_buf);
}


bool dbServer::describe_table(dbSession* session, char const* table)
{
  dbTableDescriptor* desc = db->findTableByName(table);

  if (desc == NULL)
  {
    char response[8];
    pack4(response, 0);
    pack4(response+4, -1);
    return session->sock->write(response, sizeof response);
  }
  else
  {
    int i, length = 0;
    dbFieldDescriptor* fd = desc->columns;

    for (i = desc->nColumns; --i >= 0;)
    {
      length += strlen(fd->name)+2+3;

      if (fd->refTableName != NULL)
      {
        length += strlen(fd->refTableName);
      }
      else if (fd->type == dbField::tpArray && fd->components->refTableName != NULL)
      {
        length += strlen(fd->components->refTableName);
      }

      if (fd->inverseRefName != NULL)
      {
        length += strlen(fd->inverseRefName);
      }

      fd = fd->next;
    }

    dbSmallBuffer response(length+8);
    char* p = (char*)response;
    pack4(p, length);
    pack4(p+4, desc->nColumns);
    p += 8;

    for (i = desc->nColumns, fd = desc->columns; --i >= 0;)
    {
      int flags = 0;
      *p++ = map_type(fd);

      if (fd->tTree != 0)
      {
        flags |= cli_indexed;
      }

      if (fd->hashTable != 0)
      {
        flags |= cli_hashed;
      }

      *p++ = (char)flags;
      strcpy(p, fd->name);
      p += strlen(fd->name)+1;

      if (fd->refTableName != NULL)
      {
        strcpy(p, fd->refTableName);
        p += strlen(p) + 1;
      }
      else if (fd->type == dbField::tpArray && fd->components->refTableName != NULL)
      {
        strcpy(p, fd->components->refTableName);
        p += strlen(p) + 1;
      }
      else
      {
        *p++ = '\0';
      }

      if (fd->inverseRefName != NULL)
      {
        strcpy(p, fd->inverseRefName);
        p += strlen(p) + 1;
      }
      else
      {
        *p++ = '\0';
      }

      fd = fd->next;
    }

    return session->sock->write(response, length+8);
  }
}

bool dbServer::show_tables(dbSession* session)
{
  dbTableDescriptor* desc=db->tables;

  if (desc == NULL)
  {
    char response[8];
    pack4(response, 0);
    pack4(response+4, -1);
    return session->sock->write(response, sizeof response);
  }
  else
  {
    int length = 0, n = 0;

    for (desc=db->tables; desc != NULL; desc=desc->nextDbTable)
    {
      if (strcmp(desc->name, "Metatable"))
      {
        length += strlen(desc->name)+1;
        n++;
      }
    }

    dbSmallBuffer response(length+8);
    char* p = (char*)response;
    pack4(p, length);
    pack4(p+4, n);
    p += 8;

    for (desc=db->tables; desc != NULL; desc=desc->nextDbTable)
    {
      if (strcmp(desc->name, "Metatable"))
      {
        strcpy(p, desc->name);
        p += strlen(desc->name)+1;
      }
    }

    return session->sock->write(response, length+8);
  }
}

bool dbServer::create_table(dbSession* session, char* data)
{
  db->beginTransaction(dbDatabase::dbExclusiveLock);
  db->modified = true;
  char* tableName = data;
  data += strlen(data) + 1;
  int nColumns = *data++ & 0xFF;
  cli_field_descriptor* columns = new cli_field_descriptor[nColumns];

  for (int i = 0; i < nColumns; i++)
  {
    columns[i].type = (cli_var_type)*data++;
    columns[i].flags = *data++ & 0xFF;
    columns[i].name = data;
    data += strlen(data) + 1;

    if (*data != 0)
    {
      columns[i].refTableName = data;
      data += strlen(data) + 1;
    }
    else
    {
      columns[i].refTableName = NULL;
      data += 1;
    }

    if (*data != 0)
    {
      columns[i].inverseRefFieldName = data;
      data += strlen(data) + 1;
    }
    else
    {
      columns[i].inverseRefFieldName = NULL;
      data += 1;
    }
  }

  if (session->existed_tables == NULL)
  {
    session->existed_tables = db->tables;
  }

  int4 response = dbCLI::create_table(db, tableName, nColumns, columns);
  pack4(response);
  return session->sock->write(&response, sizeof response);
}

bool dbServer::drop_table(dbSession* session, char* tableName)
{
  db->beginTransaction(dbDatabase::dbExclusiveLock);
  dbTableDescriptor* desc = db->findTableByName(tableName);
  int4 response = cli_ok;

  if (desc != NULL)
  {
    db->dropTable(desc);

    if (desc == session->existed_tables)
    {
      session->existed_tables = desc->nextDbTable;
    }

    db->unlinkTable(desc);
    desc->nextDbTable = session->dropped_tables;
    session->dropped_tables = desc;
  }
  else
  {
    response = cli_table_not_found;
  }

  pack4(response);
  return session->sock->write(&response, sizeof response);
}

bool dbServer::alter_index(dbSession* session, char* data)
{
  char* tableName = data;