cli.cpp

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

            default:
              memcpy(dst, p, n);
              p += len;
            }
          }
        }
        else
        {
          if (cb->var_type == cli_pasciiz)
          {
            dst = *(char**)dst;
          }

          memcpy(dst, p, n);
          p += len;
        }
      }
      else
      {
        switch (sizeof_type[cb->var_type])
        {

        case 2:
          p = unpack2((char*)cb->var_ptr, p);
          break;

        case 4:
          p = unpack4((char*)cb->var_ptr, p);
          break;

        case 8:
          p = unpack8((char*)cb->var_ptr, p);
          break;

        default:
          *(char*)cb->var_ptr = *p++;
        }
      }
    }
  }

  s->updated = false;
  return result;
}

int cli_get_first(int statement)
{
  return cli_get(statement, cli_cmd_get_first);
}

int cli_get_last(int statement)
{
  return cli_get(statement, cli_cmd_get_last);
}

int cli_get_next(int statement)
{
  return cli_get(statement, cli_cmd_get_next);
}

int cli_get_prev(int statement)
{
  return cli_get(statement, cli_cmd_get_prev);
}

int cli_skip(int statement, int n)
{
  return cli_get(statement, cli_cmd_skip, n);
}

int cli_seek(int statement, cli_oid_t oid)
{
  return cli_get(statement, cli_cmd_seek, oid);
}


static int send_receive(int statement, int cmd)
{
  statement_desc* s = statements.get(statement);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  if (!s->prepared)
  {
    return cli_not_fetched;
  }

  cli_request req;
  req.length = sizeof(req);
  req.cmd = cmd;
  req.stmt_id = statement;
  req.pack();
  int4 response = cli_ok;

  if (!s->session->sock->write(&req, sizeof req))
  {
    return cli_network_error;
  }

  if (!s->session->sock->read(&response, sizeof response))
  {
    return cli_network_error;
  }

  unpack4(response);
  return response;
}

int cli_freeze(int statement)
{
  return send_receive(statement, cli_cmd_freeze);
}

int cli_unfreeze(int statement)
{
  return send_receive(statement, cli_cmd_unfreeze);
}

cli_oid_t cli_get_oid(int statement)
{
  statement_desc* s = statements.get(statement);

  if (s == NULL)
  {
    return 0;
  }

  return s->oid;
}


static int cli_send_command(int session, int statement, int cmd)
{
  session_desc* s = sessions.get(session);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  cli_request req;
  req.length  = sizeof(cli_request);
  req.cmd     = cmd;
  req.stmt_id = statement;
  req.pack();

  if (!s->sock->write(&req, sizeof req))
  {
    return cli_network_error;
  }

  int4 response;

  if (!s->sock->read(&response, sizeof response))
  {
    return cli_network_error;
  }

  unpack4(response);
  return response;
}

int cli_free(int statement)
{
  statement_desc* stmt = statements.get(statement);
  session_desc* s = stmt->session;

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  statement_desc *sp, **spp = &s->stmts;

  while ((sp = *spp) != stmt)
  {
    if (sp == NULL)
    {
      return cli_bad_descriptor;
    }

    spp = &sp->next;
  }

  *spp = stmt->next;
  stmt->deallocate();
  statements.deallocate(stmt);
  cli_request req;
  req.length  = sizeof(cli_request);
  req.cmd     = cli_cmd_free_statement;
  req.stmt_id = statement;
  req.pack();

  if (!s->sock->write(&req, sizeof req))
  {
    return cli_network_error;
  }

  return cli_ok;
}


int cli_commit(int session)
{
  return cli_send_command(session, 0, cli_cmd_commit);
}

int cli_precommit(int session)
{
  return cli_send_command(session, 0, cli_cmd_precommit);
}

int cli_abort(int session)
{
  return cli_send_command(session, 0, cli_cmd_abort);
}

int cli_remove(int statement)
{
  statement_desc* s = statements.get(statement);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  if (s->oid == 0)
  {
    return cli_not_found;
  }

  if (!s->for_update)
  {
    return cli_not_update_mode;
  }

  return cli_send_command(s->session->id, s->id, cli_cmd_remove);
}


int cli_describe(int session, char const* table, cli_field_descriptor** fields)
{
  int len = sizeof(cli_request) + strlen(table) + 1;
  dbSmallBuffer buf(len);
  cli_request* req = (cli_request*)buf.base();
  req->length = len;
  req->cmd    = cli_cmd_describe_table;
  req->stmt_id = 0;
  strcpy((char*)(req+1), table);
  session_desc* s = sessions.get(session);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  req->pack();

  if (!s->sock->write(buf, len))
  {
    return cli_network_error;
  }

  int4 response[2];

  if (!s->sock->read(&response, sizeof response))
  {
    return cli_network_error;
  }

  unpack4(response[0]);
  unpack4(response[1]);
  len = response[0];
  int nFields = response[1];

  if (nFields == -1)
  {
    return cli_table_not_found;
  }

  char* p = (char*)malloc(nFields*sizeof(cli_field_descriptor) + len);
  cli_field_descriptor* fp = (cli_field_descriptor*)p;
  p += nFields*sizeof(cli_field_descriptor);

  if (!s->sock->read(p, len))
  {
    return cli_network_error;
  }

  *fields = fp;

  for (int i = nFields; --i >= 0; fp++)
  {
    fp->type = (enum cli_var_type)*p++;
    fp->flags = *p++ & 0xFF;
    fp->name = p;
    p += strlen(p) + 1;

    if (*p != 0)
    {
      fp->refTableName = p;
    }
    else
    {
      fp->refTableName = NULL;
    }

    p += strlen(p) + 1;

    if (*p != 0)
    {
      fp->inverseRefFieldName = p;
    }
    else
    {
      fp->inverseRefFieldName = NULL;
    }

    p += strlen(p) + 1;
  }

  return nFields;
}


int cli_show_tables(int session, cli_table_descriptor** tables)
{
  session_desc* s = sessions.get(session);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  cli_request req;
  req.length  = sizeof(cli_request);
  req.cmd     = cli_cmd_show_tables;
  req.stmt_id = 0;
  req.pack();

  if (!s->sock->write(&req, sizeof req))
  {
    return cli_network_error;
  }

  int4 response[2];

  if (!s->sock->read(&response, sizeof response))
  {
    return cli_network_error;
  }

  unpack4(response[0]);
  unpack4(response[1]);
  int len = response[0];
  int nTables = response[1];

  if (nTables == -1)
  {
    return cli_table_not_found;
  }

  char* p = (char*)malloc(nTables*sizeof(cli_table_descriptor) + len);
  cli_table_descriptor* fp = (cli_table_descriptor*)p;
  p += nTables*sizeof(cli_table_descriptor);

  if (!s->sock->read(p, len))
  {
    free(p);
    return cli_network_error;
  }

  *tables = fp;

  for (int i = nTables; --i >= 0; fp++)
  {
    fp->name = (char*)p;
    p += strlen((char*)p)+1;
  }

  return nTables;
}


int cli_create(char const* databaseName,
               char const* filePath,
               unsigned    transactionCommitDelay,
               int         openAttr,
               size_t      initDatabaseSize,
               size_t      extensionQuantum,
               size_t      initIndexSize,
               size_t      fileSizeLimit)
{
  return cli_bad_address;
}


int cli_create_table(int session, char const* tableName, int nColumns,
                     cli_field_descriptor* columns)
{
  int i;
  session_desc* s = sessions.get(session);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  int size = sizeof(cli_request) + 4 + strlen(tableName)+1;

  for (i = 0; i < nColumns; i++)
  {
    size += 2 + (strlen(columns[i].name)+3);

    if (columns[i].refTableName != NULL)
    {
      size += strlen(columns[i].refTableName);
    }

    if (columns[i].inverseRefFieldName != NULL)
    {
      size += strlen(columns[i].inverseRefFieldName);
    }
  }

  dbSmallBuffer buf(size);
  cli_request* req = (cli_request*)buf.base();
  req->length  = size;
  req->cmd     = cli_cmd_create_table;
  req->stmt_id = 0;
  char* dst = (char*)(req + 1);
  strcpy(dst, tableName);
  dst += strlen(dst) + 1;
  *dst++ = (char)nColumns;

  for (i = 0; i < nColumns; i++)
  {
    *dst++ = (char)columns[i].type;
    *dst++ = (char)columns[i].flags;
    strcpy(dst, columns[i].name);
    dst += strlen(dst) + 1;

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

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

  req->pack();

  if (!s->sock->write(buf, size))
  {
    return cli_network_error;
  }

  int4 response;

  if (!s->sock->read(&response, sizeof response))
  {
    return cli_network_error;
  }

  unpack4(response);
  return response;
}

int cli_drop_table(int session, char const* tableName)
{
  session_desc* s = sessions.get(session);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  int size = sizeof(cli_request) + strlen(tableName) + 1;
  dbSmallBuffer buf(size);
  cli_request* req = (cli_request*)buf.base();
  req->length  = size;
  req->cmd     = cli_cmd_drop_table;
  req->stmt_id = 0;
  strcpy((char*)(req + 1), tableName);
  req->pack();

  if (!s->sock->write(buf, size))
  {
    return cli_network_error;
  }

  int4 response;

  if (!s->sock->read(&response, sizeof response))
  {
    return cli_network_error;
  }

  unpack4(response);
  return response;
}

int cli_alter_index(int session, char const* tableName, char const* fieldName, int newFlags)
{
  session_desc* s = sessions.get(session);

  if (s == NULL)
  {
    return cli_bad_descriptor;
  }

  int size = sizeof(cli_request) + 1 + strlen(tableName)+strlen(fieldName)+2;
  dbSmallBuffer buf(size);
  cli_request* req = (cli_request*)buf.base();
  req->length  = size;
  req->cmd     = cli_cmd_alter_index;
  req->stmt_id = 0;
  char* dst = (char*)(req + 1);
  strcpy(dst, tableName);
  dst += strlen(dst) + 1;
  strcpy(dst, fieldName);
  dst += strlen(dst) + 1;
  *dst++ = newFlags;
  req->pack();

  if (!s->sock->write(buf, size))
  {
    return cli_network_error;
  }

  int4 response;

  if (!s->sock->read(&response, sizeof response))
  {
    return cli_network_error;
  }

  unpack4(response);
  return response;
}


cli_error_handler cli_set_error_handler(int session, cli_error_handler new_handler)
{
  return NULL;
}

int cli_create_replication_node(int         nodeId,
                                int         nServers,
                                char*       nodeNames[],
                                char const* databaseName,
                                char const* filePath,
                                int         openAttr,
                                size_t      initDatabaseSize,
                                size_t      extensionQuantum,
                                size_t      initIndexSize,
                                size_t      fileSizeLimit)
{
  return cli_not_implemented;
}

int cli_attach(int session)
{
  return cli_not_implemented;
}

int cli_detach(int session, int detach_mode)
{
  return cli_not_implemented;
}

void cli_free_memory(int, void* ptr)
{
  free(ptr);
}

int cli_get_database_state(int session, cli_database_monitor* monitor)
{
  return cli_not_implemented;
}

void cli_set_trace_function(cli_trace_function_t)
{}

int cli_prepare_query(int session, char* query)
{
  return cli_not_implemented;
}

int cli_execute_query(int statement, int for_update, void* record_struct, ...)
{
  return cli_not_implemented;
}

int cli_insert_struct(int session, char const* table_name, void* record_struct, cli_oid_t* oid)
{
  return cli_not_implemented;
}