cli.cpp

来自「一个功能强大的内存数据库源代码,c++编写,有详细的注释」· C++ 代码 · 共 1,213 行 · 第 1/3 页

		  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 cli_ok;
}

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


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;
	p += 1;
	fp->name = (char*)p;
	p += strlen((char*)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;
}