localcli.cpp

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

	      case cli_int4:
		*(int4*)dst = *(cli_int4_t*)src;
		continue;
	      case cli_int8:
		*(int4*)dst = (int4)*(db_int8*)src;
		continue;
	      case cli_real4:
		*(int4*)dst = (int4)*(cli_real4_t*)src;
		continue;
	      case cli_real8:
		*(int4*)dst = (int4)*(cli_real8_t*)src;
		continue;
	    }
	    break;
	  case dbField::tpInt8:
	    switch (cb->var_type) {
	      case cli_bool:
		*(db_int8*)dst = *(cli_bool_t*)src ? 1 : 0;
		continue;
	      case cli_int1:
		*(db_int8*)dst = *(cli_int1_t*)src;
		continue;
	      case cli_int2:
		*(db_int8*)dst = *(cli_int2_t*)src;
		continue;
	      case cli_int4:
		*(db_int8*)dst = *(cli_int4_t*)src;
		continue;
	      case cli_int8:
		*(db_int8*)dst = *(db_int8*)src;
		continue;
	      case cli_real4:
		*(db_int8*)dst = (db_int8)*(cli_real4_t*)src;
		continue;
	      case cli_real8:
		*(db_int8*)dst = (db_int8)*(cli_real8_t*)src;
		continue;
	    }
	    break;
	  case dbField::tpReal4:
	    switch (cb->var_type) {
	      case cli_bool:
		*(real4*)dst = *(cli_bool_t*)src ? 1 : 0;
		continue;
	      case cli_int1:
		*(real4*)dst = *(cli_int1_t*)src;
		continue;
	      case cli_int2:
		*(real4*)dst = *(cli_int2_t*)src;
		continue;
	      case cli_int4:
		*(real4*)dst = *(cli_int4_t*)src;
		continue;
	      case cli_int8:
		*(real4*)dst = *(db_int8*)src;
		continue;
	      case cli_real4:
		*(real4*)dst = *(cli_real4_t*)src;
		continue;
	      case cli_real8:
		*(real4*)dst = (real4)*(cli_real8_t*)src;
		continue;
	    }
	    break;
	  case dbField::tpReal8:
	    switch (cb->var_type) {
	      case cli_bool:
		*(real8*)dst = *(cli_bool_t*)src ? 1 : 0;
		continue;
	      case cli_int1:
		*(real8*)dst = *(cli_int1_t*)src;
		continue;
	      case cli_int2:
		*(real8*)dst = *(cli_int2_t*)src;
		continue;
	      case cli_int4:
		*(real8*)dst = *(cli_int4_t*)src;
		continue;
	      case cli_int8:
		*(real8*)dst = *(db_int8*)src;
		continue;
	      case cli_real4:
		*(real8*)dst = *(cli_real4_t*)src;
		continue;
	      case cli_real8:
		*(real8*)dst = *(cli_real8_t*)src;
		continue;
	    }
	    break;
	  case dbField::tpReference:
	    if (cb->var_type == cli_oid) { 
		*(oid_t*)dst = *(cli_oid_t*)src;
		continue;
	    }
	    break;
	  case dbField::tpString:
	    if (cb->var_type == cli_pasciiz) { 
		*(char**)dst = *(char**)src;
		continue;
	    } else if (cb->var_type == cli_asciiz) { 
		if (cb->get_fnc != NULL) {
		    int len;
		    src = (char*)cb->get_fnc(cb->var_type, src, &len, 
					     cb->name, stmt->id);
		}
		*(char**)dst = src;
		continue;
	    }
	    break;
	  case dbField::tpArray:
	    if (cb->var_type >= cli_array_of_oid && cb->var_type <= cli_array_of_string) 
	    { 
		int size = 0;
		if (cb->get_fnc != NULL) {
		    src = (char*)cb->get_fnc(cb->var_type, src, &size, 
					     cb->name, stmt->id);
		} else { 
		    if (cb->var_len != NULL) {
			size = *cb->var_len; 
		    } else { 
			return cli_incompatible_type;
		    }
		}
		if (cb->var_type == cli_array_of_string) { 
		    if (fd->components->type != dbField::tpString) { 
			return cli_incompatible_type;
		    }
		} else if ((size_t)sizeof_type[cb->var_type - cli_array_of_oid] != fd->components->appSize) {
		    return cli_incompatible_type;
		}
		dbAnyArray::arrayAllocator((dbAnyArray*)dst, src, size);
		continue;
	    }
	}
	return cli_unsupported_type;
    }
    return cli_ok;
}



int cli_insert(int statement, cli_oid_t* oid)
{
    return dbCLI::instance.insert(statement, oid);
}

int dbCLI::insert(int statement, cli_oid_t* oid)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	sql_scanner scanner(stmt->sql);
	if (scanner.get() != tkn_insert
	    || scanner.get() != tkn_into
	    || scanner.get() != tkn_ident)
	{
	    return cli_bad_statement;
	}
	int rc = match_columns(scanner.identifier(), stmt);
	if (rc != cli_ok) {
	    return rc;
	}
	stmt->prepared = true;
    }
    dbSmallBuffer buf(stmt->table->appSize);    
    char* obj = buf.base();
    memset(obj, 0, stmt->table->appSize);  
    dbFieldDescriptor *first = stmt->table->columns, *fd = first;
    do { 
	if (fd->appType == dbField::tpString) { 
	    *(char**)(obj + fd->appOffs) = "";
	}
    } while ((fd = fd->next) != first);
    
    int rc = store_columns(buf.base(), stmt);
    if (rc != cli_ok) { 
	return rc;
    }

    dbAnyReference ref;
    stmt->session->db->insertRecord(stmt->table, &ref, buf.base());
    stmt->oid = ref.getOid();
    if (oid != NULL) { 
	*oid = ref.getOid();
    }
    if (stmt->n_autoincremented_columns > 0) { 
	for (column_binding* cb = stmt->columns; cb != NULL; cb = cb->next) {
	    if (cb->var_type == cli_autoincrement) { 
		*(cli_int4_t*)cb->var_ptr = ref.getOid();
	    }
	}
    }
    return cli_ok;
}

int cli_update(int statement)
{
    return dbCLI::instance.update(statement);
}

int dbCLI::update(int statement)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    if (!stmt->for_update) {
	return cli_not_update_mode;
    }
    if (stmt->updated) { 
	return cli_already_updated;
    }
    if (stmt->cursor.isEmpty()) { 
	return cli_not_found;
    }
    dbSmallBuffer buf(stmt->table->appSize); 
    char* record = buf.base();
    memset(record, 0, stmt->table->appSize);
    stmt->cursor.setRecord((byte*)record);
    stmt->cursor.fetch();
    
    int rc = store_columns(buf.base(), stmt);
    if (rc != cli_ok) { 
	return rc;
    }
    stmt->cursor.update();
    stmt->updated = true;
    return cli_ok;
}

int cli_freeze(int statement)
{
    return dbCLI::instance.freeze(statement);
}

int dbCLI::freeze(int statement)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    stmt->cursor.freeze();
    return cli_ok;
}

int cli_unfreeze(int statement)
{
    return dbCLI::instance.unfreeze(statement);
}

int dbCLI::unfreeze(int statement)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    stmt->cursor.unfreeze();
    return cli_ok;
}

int cli_get_first(int statement)
{
    return dbCLI::instance.get_first(statement);
}

int dbCLI::get_first(int statement)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    if (!stmt->cursor.gotoFirst()) { 
	return cli_not_found;
    }
    return fetch_columns(stmt);
}

int cli_get_last(int statement)
{
    return dbCLI::instance.get_last(statement);
}

int dbCLI::get_last(int statement)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    if (!stmt->cursor.gotoLast()) { 
	return cli_not_found;
    }
    return fetch_columns(stmt);
}

int cli_get_next(int statement)
{
    return dbCLI::instance.get_next(statement);
}

int dbCLI::get_next(int statement)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    if (!((stmt->first_fetch && stmt->cursor.gotoFirst()) ||
	  (!stmt->first_fetch && stmt->cursor.gotoNext())))
    {
	return cli_not_found;
    }
    return fetch_columns(stmt);
}

int cli_get_prev(int statement)
{
    return dbCLI::instance.get_prev(statement);
}

int dbCLI::get_prev(int statement)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    if (!((stmt->first_fetch && stmt->cursor.gotoLast()) ||
	  (!stmt->first_fetch && stmt->cursor.gotoPrev())))
    {
	return cli_not_found;
    }
    return fetch_columns(stmt);
}

int cli_skip(int statement, int n)
{
    return dbCLI::instance.skip(statement, n);
}

int dbCLI::skip(int statement, int n)
{
    statement_desc* stmt = statements.get(statement);    
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    if (!stmt->prepared) { 
	return cli_not_fetched;
    }
    if ((n > 0 && !((stmt->first_fetch && stmt->cursor.gotoFirst() && stmt->cursor.skip(n-1)
		     || (!stmt->first_fetch && stmt->cursor.skip(n)))))
	|| (n < 0 && !((stmt->first_fetch && stmt->cursor.gotoLast() && stmt->cursor.skip(n+1)
			|| (!stmt->first_fetch && stmt->cursor.skip(n))))))
    {
	return cli_not_found;
    } 
    return fetch_columns(stmt);
}



cli_oid_t cli_get_oid(int statement)
{
    return dbCLI::instance.get_current_oid(statement);
}

cli_oid_t dbCLI::get_current_oid(int statement)
{
    statement_desc* s = statements.get(statement);
    if (s == NULL) {
	return cli_bad_descriptor;
    }
    return s->cursor.currId;
}


int cli_free(int statement)
{
    return dbCLI::instance.free_statement(statement);
}

int dbCLI::free_statement(int statement)
{
    statement_desc* stmt = statements.get(statement);
    if (stmt == NULL) {
	return cli_bad_descriptor;
    }
    return free_statement(stmt);
}

int dbCLI::free_statement(statement_desc* stmt)
{
    statement_desc *sp, **spp = &stmt->session->stmts;
    while ((sp = *spp) != stmt) {
	if (sp == NULL) {
	    return cli_bad_descriptor;
	}
	spp = &sp->next;
    }
    *spp = stmt->next;
    delete[] stmt->sql;
    column_binding *cb, *next_cb;
    for (cb = stmt->columns; cb != NULL; cb = next_cb) {
	next_cb = cb->next;
	delete[] cb->name;
	column_allocator.free(cb);
    }
    parameter_binding *pb, *next_pb;
    for (pb = stmt->params; pb != NULL; pb = next_pb) {
	next_pb = pb->next;
	delete[] pb->name;
	parameter_allocator.free(pb);
    }
    statements.free(stmt);
    return cli_ok;
}


int cli_commit(int session)
{
    return dbCLI::instance.commit(session);
}

int dbCLI::commit(int session)
{
    session_desc* s = sessions.get(session);
    if (s == NULL) {
	return cli_bad_descriptor;
    }
    while (s->dropped_tables != NULL) {
	dbTableDescriptor* next = s->dropped_tables->nextDbTable;
	delete s->dropped_tables;
	s->dropped_tables = next;
    }
    s->db->commit();
    s->existed_tables = s->db->tables;
    return cli_ok;
}

int cli_precommit(int session)
{
    return dbCLI::instance.precommit(session);
}

int dbCLI::precommit(int session)
{
    session_desc* s = sessions.get(session);
    if (s == NULL) {
	return cli_bad_descriptor;
    }
    s->db->precommit();
    return cli_ok;
}

int cli_abort(int session)
{
    return dbCLI::instance.abort(session);
}

int dbCLI::abort(int session)
{
    session_desc* s = sessions.get(session);
    if (s == NULL) {
	return cli_bad_descriptor;
    }
    dbDatabase* db = s->db;
    while (s->dropped_tables != NULL) {
	dbTableDescriptor* next = s->dropped_tables->nextDbTable;
	db->linkTable(s->dropped_tables, s->dropped_tables->tableId);
	s->dropped_tables = next;
    }
    s->db->rollback();
    while (db->tables != s->existed_tables) {