static PyObject* ConnectionObject_autocommit(ConnectionObject *self, PyObject *args) { int flag, status = 1; char query[256]; drizzle_return_t ret; drizzle_result_st result; if (!PyArg_ParseTuple(args, "i", &flag)) { return NULL; } DEBUG("autocommit %d", flag); snprintf(query, 256, "SET AUTOCOMMIT=%d;", flag); BDEBUG("query %s", query); while(status){ (void)drizzle_query(self->con, &result, query, 256, &ret); status = io_wait(self->con, ret); if (status == -1){ goto error; } } drizzle_result_free(&result); Py_RETURN_NONE; error: drizzle_result_free(&result); PyErr_SetString(PyExc_IOError, drizzle_error(drizzle)); return NULL; }
int dbt2_sql_close_cursor(struct db_context_t *dbc, struct sql_result_t * sql_result) { if (sql_result->result_set) { drizzle_result_free(sql_result->result_set); } return 1; }
static PyObject* ConnectionObject_rollback(ConnectionObject *self, PyObject *args) { int status = 1; drizzle_return_t ret; drizzle_result_st result; while(status){ (void)drizzle_query(self->con, &result, "ROLLBACK;", 9, &ret); status = io_wait(self->con, ret); if (status == -1){ goto error; } } drizzle_result_free(&result); Py_RETURN_NONE; error: drizzle_result_free(&result); PyErr_SetString(PyExc_IOError, drizzle_error(drizzle)); return NULL; }
void free_result_t(result_t *res) { if (res->description) { Py_CLEAR(res->description); } if (res->types) { PyMem_Free(res->types); } drizzle_result_free(res->result); PyMem_Free(res); }
void do_process(connection_t *con) { drizzle_st *drizzle; drizzle_return_t ret; drizzle_con_st *dc = con->dc; drizzle_command_t command; uint8_t *data = NULL; size_t total; dbgin(); drizzle = con->client->drizzle; /* ret = drizzle_con_wait(drizzle); if (ret != DRIZZLE_RETURN_OK) { printf("drizzle_con_wait failed:%s\n", drizzle_error(drizzle)); return; } */ while (1) { switch (con->state) { case INIT: /* Handshake packets */ drizzle_con_set_protocol_version(dc, 10); drizzle_con_set_server_version(dc, "ev_drizzle_server demo 0.0.1"); drizzle_con_set_thread_id(dc, 1); drizzle_con_set_scramble(dc, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST"); drizzle_con_set_capabilities(dc, DRIZZLE_CAPABILITIES_NONE); drizzle_con_set_charset(dc, 8); drizzle_con_set_status(dc, DRIZZLE_CON_STATUS_NONE); drizzle_con_set_max_packet_size(dc, DRIZZLE_MAX_PACKET_SIZE); con->state = HANDSHAKE_WRITE; break; case HANDSHAKE_WRITE: printf("handshake write\n"); ret = drizzle_handshake_server_write(dc); if (ret == DRIZZLE_RETURN_IO_WAIT) { return; } if (ret == DRIZZLE_RETURN_OK) { stop_watch_write(con); con->state = HANDSHAKE_READ; break; } printf("drizzle_handshake_server_write error:%s", drizzle_error(drizzle)); exit(1); break; case HANDSHAKE_READ: printf("handshake read\n"); /* prepare libdrizzle internal event */ dc->revents |= POLLIN; ret = drizzle_handshake_client_read(dc); if (ret == DRIZZLE_RETURN_IO_WAIT) { return; } if (ret == DRIZZLE_RETURN_OK) { con->state = HANDSHAKE_DONE; break; } printf("drizzle_handshake_server_read error:%s", drizzle_error(drizzle)); exit(1); break; case HANDSHAKE_DONE: printf("handshake done\n"); con->result = (drizzle_result_st *) malloc(sizeof(drizzle_result_st)); if (drizzle_result_create(dc, con->result) == NULL) { printf("drizzle_result_create error:%s", drizzle_error(drizzle)); exit(1); } ret = drizzle_result_write(dc, con->result, true); if (ret != DRIZZLE_RETURN_OK) { printf("drizzle_result_write error:%s", drizzle_error(drizzle)); exit(1); } con->state = PREPARE_COMMAND; break; case PREPARE_COMMAND: printf("prepare command\n"); /* prepare libdrizzle internal event */ dc->revents |= POLLIN; drizzle_result_free(dc->result); data = (uint8_t *) drizzle_con_command_buffer(dc, &command, &total, &ret); if (ret == DRIZZLE_RETURN_LOST_CONNECTION || (ret == DRIZZLE_RETURN_OK && command == DRIZZLE_COMMAND_QUIT)) { free(data); do_finalize(con); return; } if (ret == DRIZZLE_RETURN_IO_WAIT) { return; } printf("Command data:%s\n", data); if (drizzle_result_create(dc, con->result) == NULL) { printf("drizzle_result_create error:%s", drizzle_error(drizzle)); exit(1); } if (command != DRIZZLE_COMMAND_QUERY) { printf("command is not QUERY command\n"); ret = drizzle_result_write(dc, dc->result, true); if (ret != DRIZZLE_RETURN_OK) { printf("drizzle_result_write error:%s", drizzle_error(drizzle)); exit(1); } continue; } ret = drizzle_result_write(dc, dc->result, true); if (ret != DRIZZLE_RETURN_OK) { printf("drizzle_result_write error:%s", drizzle_error(drizzle)); exit(1); } return; break; default: printf("Unsupported state %d\n", con->state); //sleep(10); } } }
static void _client(drizzle_con_st *con, client_state_st *state) { drizzle_return_t ret; drizzle_column_st *column; drizzle_row_t row; size_t *field_sizes; switch(state->state) { case CLIENT_STATE_START: drizzle_test("drizzle_query_str"); (void)drizzle_query_str(con, &state->result, "SELECT", &ret); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = CLIENT_STATE_START; return; } else if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT) { state->state= CLIENT_STATE_DONE; return; } else if (ret != DRIZZLE_RETURN_OK) { drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); } case CLIENT_STATE_RESULT: drizzle_test("drizzle_result_buffer"); ret = drizzle_result_buffer(&state->result); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = CLIENT_STATE_RESULT; return; } else if (ret != DRIZZLE_RETURN_OK) { drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); } drizzle_test("drizzle_con_protocol_version"); if (drizzle_con_protocol_version(con) != 10) { drizzle_test_error("no match"); } drizzle_test("drizzle_con_server_version"); if (strcmp(drizzle_con_server_version(con), "test_version")) drizzle_test_error("no match"); drizzle_test("drizzle_con_thread_id"); if (drizzle_con_thread_id(con) != 1) drizzle_test_error("no match"); drizzle_test("drizzle_con_scramble"); if (memcmp(drizzle_con_scramble(con), "ABCDEFGHIJKLMNOPQRST", DRIZZLE_MAX_SCRAMBLE_SIZE)) { drizzle_test_error("no match"); } /* We default to MySQL protocol right now, which sets this flag. */ drizzle_test("drizzle_con_capabilities"); if (drizzle_con_capabilities(con) != DRIZZLE_CAPABILITIES_PROTOCOL_41) drizzle_test_error("no match"); drizzle_test("drizzle_con_charset"); if (drizzle_con_charset(con) != 8) drizzle_test_error("no match"); drizzle_test("drizzle_con_status"); if (drizzle_con_status(con) != DRIZZLE_CON_STATUS_NONE) drizzle_test_error("no match"); drizzle_test("drizzle_con_packet_size"); if (drizzle_con_max_packet_size(con) != DRIZZLE_MAX_PACKET_SIZE) drizzle_test_error("no match"); drizzle_test("drizzle_column_next"); column= drizzle_column_next(&state->result); if (column == NULL) drizzle_test_error("column not found"); drizzle_test("drizzle_column_drizzle_result"); if (drizzle_column_drizzle_result(column) != &state->result) drizzle_test_error("no match"); drizzle_test("drizzle_column_catalog"); if (strcmp(drizzle_column_catalog(column), "test_catalog")) drizzle_test_error("no match"); drizzle_test("drizzle_column_db"); if (strcmp(drizzle_column_db(column), "test_db")) drizzle_test_error("no match"); drizzle_test("drizzle_column_table"); if (strcmp(drizzle_column_table(column), "test_table")) drizzle_test_error("no match"); drizzle_test("drizzle_column_orig_table"); if (strcmp(drizzle_column_orig_table(column), "test_orig_table")) drizzle_test_error("no match"); drizzle_test("drizzle_column_name"); if (strcmp(drizzle_column_name(column), "test_column_1")) drizzle_test_error("no match"); drizzle_test("drizzle_column_orig_name"); if (strcmp(drizzle_column_orig_name(column), "test_orig_column_1")) drizzle_test_error("no match"); drizzle_test("drizzle_column_charset"); if (drizzle_column_charset(column) != 8) drizzle_test_error("no match"); drizzle_test("drizzle_column_size"); if (drizzle_column_size(column) != 32) drizzle_test_error("no match"); drizzle_test("drizzle_column_max_size"); if (drizzle_column_max_size(column) != 12) drizzle_test_error("no match"); drizzle_test("drizzle_column_type_drizzle"); if (drizzle_column_type_drizzle(column) != DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR) drizzle_test_error("no match"); drizzle_test("drizzle_column_flags"); if (drizzle_column_flags(column) != DRIZZLE_COLUMN_FLAGS_NONE) drizzle_test_error("no match"); drizzle_test("drizzle_column_next"); column= drizzle_column_next(&state->result); if (column == NULL) drizzle_test_error("column not found"); drizzle_test("drizzle_column_name"); if (strcmp(drizzle_column_name(column), "test_column_2")) drizzle_test_error("no match"); drizzle_test("drizzle_column_next"); column= drizzle_column_next(&state->result); if (column != NULL) drizzle_test_error("column found"); drizzle_test("drizzle_column_prev"); column= drizzle_column_prev(&state->result); if (column == NULL) drizzle_test_error("column not found"); drizzle_test("drizzle_column_name"); if (strcmp(drizzle_column_name(column), "test_column_2")) drizzle_test_error("no match"); drizzle_test("drizzle_row_next"); row= drizzle_row_next(&state->result); if (row == NULL) drizzle_test_error("row not found"); if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2")) drizzle_test_error("no match"); drizzle_test("drizzle_row_field_sizes"); field_sizes= drizzle_row_field_sizes(&state->result); if (field_sizes[0] != 12 || field_sizes[1] != 12) drizzle_test_error("no match"); drizzle_test("drizzle_row_prev"); row = drizzle_row_prev(&state->result); if (row == NULL) drizzle_test_error("row not found"); if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2")) drizzle_test_error("no match"); drizzle_test("drizzle_row_next"); row = drizzle_row_next(&state->result); drizzle_test("drizzle_row_index"); row = drizzle_row_index(&state->result, 0); if (row == NULL) drizzle_test_error("row not found"); if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2")) drizzle_test_error("no match"); drizzle_test("drizzle_row_index"); row = drizzle_row_index(&state->result, 1); if (row != NULL) drizzle_test_error("row found"); drizzle_test("drizzle_result_free"); drizzle_result_free(&state->result); state->state = CLIENT_STATE_DONE; case CLIENT_STATE_DONE: return; default: drizzle_test_error("invalid client state"); } }
static void _server(drizzle_con_st *con, server_state_st *state) { drizzle_return_t ret; const drizzle_field_t fields[2]= { (drizzle_field_t)"test_field_1", (drizzle_field_t)"test_field_2" }; const size_t field_sizes[2]= { 12, 12 }; switch(state->state) { case SERVER_STATE_START: drizzle_con_set_protocol_version(con, 10); drizzle_con_set_server_version(con, "test_version"); drizzle_con_set_thread_id(con, 1); drizzle_con_set_scramble(con, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST"); drizzle_con_set_capabilities(con, DRIZZLE_CAPABILITIES_NONE); drizzle_con_set_charset(con, 8); drizzle_con_set_status(con, DRIZZLE_CON_STATUS_NONE); drizzle_con_set_max_packet_size(con, DRIZZLE_MAX_PACKET_SIZE); case SERVER_STATE_HANDSHAKE_WRITE: drizzle_test("drizzle_handshake_server_write"); ret= drizzle_handshake_server_write(con); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_HANDSHAKE_WRITE; return; } else if (ret != DRIZZLE_RETURN_OK) { drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); } case SERVER_STATE_HANDSHAKE_READ: drizzle_test("drizzle_handshake_client_read"); ret= drizzle_handshake_client_read(con); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_HANDSHAKE_READ; return; } else if (ret == DRIZZLE_RETURN_LOST_CONNECTION) { return; } else if (ret == DRIZZLE_RETURN_COULD_NOT_CONNECT) { return; } else if (ret != DRIZZLE_RETURN_OK) { drizzle_test_error("returned %s (%s)", drizzle_con_error(con), drizzle_strerror(ret)); } drizzle_test("drizzle_result_create"); if (drizzle_result_create(con, &state->result) == NULL) drizzle_test_error("returned %s", drizzle_con_error(con)); case SERVER_STATE_HANDSHAKE_RESULT: drizzle_test("drizzle_handshake_result_write"); ret= drizzle_result_write(con, &state->result, true); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_HANDSHAKE_RESULT; return; } else if (ret != DRIZZLE_RETURN_OK) drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); drizzle_result_free(&state->result); case SERVER_STATE_COMMAND_BUFFER: drizzle_test("drizzle_con_command_buffer"); state->data= drizzle_con_command_buffer(con, &state->command, &state->total, &ret); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_COMMAND_BUFFER; return; } else if (ret != DRIZZLE_RETURN_OK) drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); if (state->command != DRIZZLE_COMMAND_QUERY) drizzle_test_error("command was not a query"); if (state->total != 6 && !memcmp(state->data, "SELECT", 6)) drizzle_test_error("query doesn't match"); if (state->data != NULL) { free(state->data); state->data= NULL; } drizzle_test("drizzle_result_create"); if (drizzle_result_create(con, &state->result) == NULL) drizzle_test_error("returned %s", drizzle_con_error(con)); drizzle_result_set_column_count(&state->result, 2); case SERVER_STATE_RESULT_HEADER: drizzle_test("drizzle_handshake_result_write"); ret= drizzle_result_write(con, &state->result, false); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_RESULT_HEADER; return; } else if (ret != DRIZZLE_RETURN_OK) drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); drizzle_test("drizzle_column_create"); if (drizzle_column_create(&state->result, &state->column) == NULL) drizzle_test_error("returned %s", drizzle_con_error(con)); drizzle_column_set_catalog(&state->column, "test_catalog"); drizzle_column_set_db(&state->column, "test_db"); drizzle_column_set_table(&state->column, "test_table"); drizzle_column_set_orig_table(&state->column, "test_orig_table"); drizzle_column_set_name(&state->column, "test_column_1"); drizzle_column_set_orig_name(&state->column, "test_orig_column_1"); drizzle_column_set_charset(&state->column, 8); drizzle_column_set_size(&state->column, 32); drizzle_column_set_type(&state->column, DRIZZLE_COLUMN_TYPE_VARCHAR); drizzle_column_set_flags(&state->column, DRIZZLE_COLUMN_FLAGS_NONE); case SERVER_STATE_RESULT_COLUMN_1: drizzle_test("drizzle_column_write"); ret= drizzle_column_write(&state->result, &state->column); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_RESULT_COLUMN_1; return; } else if (ret != DRIZZLE_RETURN_OK) drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); drizzle_column_set_name(&state->column, "test_column_2"); drizzle_column_set_orig_name(&state->column, "test_orig_column_2"); case SERVER_STATE_RESULT_COLUMN_2: drizzle_test("drizzle_column_write"); ret= drizzle_column_write(&state->result, &state->column); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_RESULT_COLUMN_2; return; } else if (ret != DRIZZLE_RETURN_OK) drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); drizzle_test("drizzle_column_free"); drizzle_column_free(&state->column); drizzle_result_set_eof(&state->result, true); case SERVER_STATE_RESULT_COLUMN_EOF: drizzle_test("drizzle_handshake_result_write"); ret= drizzle_result_write(con, &state->result, false); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_RESULT_COLUMN_EOF; return; } else if (ret != DRIZZLE_RETURN_OK) drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); drizzle_result_calc_row_size(&state->result, fields, field_sizes); case SERVER_STATE_RESULT_ROW_1: ret= drizzle_row_write(&state->result); case SERVER_STATE_RESULT_ROW_1_FIELD_1: ret= drizzle_field_write(&state->result, fields[0], field_sizes[0], field_sizes[0]); case SERVER_STATE_RESULT_ROW_1_FIELD_2: ret= drizzle_field_write(&state->result, fields[1], field_sizes[1], field_sizes[1]); case SERVER_STATE_RESULT_ROW_EOF: drizzle_test("drizzle_handshake_result_write"); ret= drizzle_result_write(con, &state->result, true); if (ret == DRIZZLE_RETURN_IO_WAIT) { state->state = SERVER_STATE_RESULT_ROW_EOF; return; } else if (ret != DRIZZLE_RETURN_OK) drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret); drizzle_result_free(&state->result); state->state = SERVER_STATE_DONE; case SERVER_STATE_DONE: return; default: drizzle_test_error("invalid server state"); } }
int main(int argc, char *argv[]) { (void) argc; (void) argv; drizzle_row_t row; int num_fields; drizzle_result_st *result; int table_size; #ifdef TEST_PREPARED_STATEMENTS drizzle_stmt_st *sth; #endif drizzle_st *con= drizzle_create(getenv("MYSQL_SERVER"), getenv("MYSQL_PORT") ? atoi("MYSQL_PORT") : DRIZZLE_DEFAULT_TCP_PORT, getenv("MYSQL_USER"), getenv("MYSQL_PASSWORD"), getenv("MYSQL_SCHEMA"), 0); ASSERT_NOT_NULL_(con, "Drizzle connection object creation error"); drizzle_return_t driz_ret= drizzle_connect(con); if (driz_ret == DRIZZLE_RETURN_COULD_NOT_CONNECT) { char error[DRIZZLE_MAX_ERROR_SIZE]; strncpy(error, drizzle_error(con), DRIZZLE_MAX_ERROR_SIZE); drizzle_quit(con); SKIP_IF_(driz_ret == DRIZZLE_RETURN_COULD_NOT_CONNECT, "%s(%s)", error, drizzle_strerror(driz_ret)); } ASSERT_EQ_(DRIZZLE_RETURN_OK, driz_ret, "drizzle_connect(): %s(%s)", drizzle_error(con), drizzle_strerror(driz_ret)); CHECKED_QUERY("DROP SCHEMA IF EXISTS test_nulls"); CHECKED_QUERY("CREATE SCHEMA test_nulls"); driz_ret= drizzle_select_db(con, "test_nulls"); ASSERT_EQ_(DRIZZLE_RETURN_OK, driz_ret, "USE test_nulls"); CHECKED_QUERY("create table test_nulls.t1 (a int, b int, c int, d int, e int, f int, g int, h int, i int, j int, k int)"); #define NCOLS 11 char *querybuf = calloc(256 + 60*64, 1); strcpy(querybuf, "insert into test_nulls.t1 values "); char *p = querybuf + strlen(querybuf); for(int sym = 0; sym < 64; sym++) { int cn = 0; *p++ = '('; #define APPENDMAYBE(b) if (sym & b) { strcpy(p, "NULL"); p += 4; } else { p += sprintf(p, "%d", sym*NCOLS + cn); } APPENDMAYBE(0x01); *p++ = ','; cn++; APPENDMAYBE(0x02); *p++ = ','; cn++; APPENDMAYBE(0x04); cn++; p += sprintf(p, ",%d,%d,%d,%d,", sym*NCOLS + 3, sym*NCOLS + 4, sym*NCOLS + 5, sym*NCOLS + 6); cn += 4; APPENDMAYBE(0x08); cn++; p += sprintf(p, ",%d,", sym*NCOLS + 8); cn++; APPENDMAYBE(0x10); *p++ = ','; cn++; APPENDMAYBE(0x20); cn++; *p++ = ')'; if (sym < 63) *p++ = ','; #undef APPENDMAYBE } CHECKED_QUERY(querybuf); #ifdef TEST_PREPARED_STATEMENTS strcpy(querybuf, "insert into test_nulls.t1 values (?,?,?,?,?,?,?,?,?,?,?)"); sth = drizzle_stmt_prepare(con, querybuf, strlen(querybuf), &driz_ret); ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, preparing \"%s\"", drizzle_strerror(driz_ret), drizzle_error(con), querybuf); for(int sym = 0; sym < 64; sym++) { // driz_ret= drizzle_stmt_reset(sth); // ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, resetting statement", drizzle_strerror(driz_ret), drizzle_error(con)); #define SETMAYBE(cn,b) if (sym & b) driz_ret = drizzle_stmt_set_null(sth, cn); else SETALWAYS(cn); #define SETALWAYS(cn) driz_ret = drizzle_stmt_set_short(sth, cn, sym*NCOLS + cn + 1000, 0) ASSERT_EQ(driz_ret, DRIZZLE_RETURN_OK); SETMAYBE(0,0x01); SETMAYBE(1,0x02); SETMAYBE(2,0x04); SETALWAYS(3); SETALWAYS(4); SETALWAYS(5); SETALWAYS(6); SETMAYBE(7,0x08); SETALWAYS(8); SETMAYBE(9,0x10); SETMAYBE(10,0x20); #undef SETMAYBE driz_ret = drizzle_stmt_execute(sth); ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, executing insert, sym=%d", drizzle_strerror(driz_ret), drizzle_error(con), sym); driz_ret = drizzle_stmt_buffer(sth); ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, buffering result, sym=%d", drizzle_strerror(driz_ret), drizzle_error(con), sym); // ASSERT_EQ(drizzle_stmt_affected_rows, 1); } ASSERT_EQ(drizzle_stmt_close(sth), DRIZZLE_RETURN_OK); table_size = 128; #else table_size = 64; #endif CHECKED_QUERY("select a,b,c,d,e,f,g,h,i,j,k from test_nulls.t1 order by e"); drizzle_result_buffer(result); num_fields= drizzle_result_column_count(result); ASSERT_EQ_(num_fields, NCOLS, "Bad number of fields, expected %d, got %d", 11, num_fields); int cur_row = 0; char nbuf[16]; while ((row = drizzle_row_next(result))) { cur_row ++; int sym, rowbase; /* 'sym' is the value used to decide which fields have NULLs or not. * 'rowbase' is the number that would be stored in the first field of this * row (assuming it's non-NULL). */ if (cur_row <= 64) { sym = cur_row - 1; rowbase = sym*NCOLS; } else { sym = cur_row - 65; rowbase = 1000 + sym*NCOLS; } #define NULLMAYBE(cn, b) if (sym & b) { ASSERT_NULL_(row[cn], "Column %d, row %d should be NULL", cn+1, cur_row); } else { ASSERT_NOT_NULL_(row[cn], "Column %d, row %d should not be NULL", cn+1, cur_row); sprintf(nbuf, "%d", rowbase+cn); ASSERT_STREQ(row[cn], nbuf); } #define NULLNEVER(cn) NULLMAYBE(cn, 0) NULLMAYBE(0, 0x01); NULLMAYBE(1, 0x02); NULLMAYBE(2, 0x04); NULLNEVER(3); NULLNEVER(4); NULLNEVER(5); NULLNEVER(6); NULLMAYBE(7, 0x08); NULLNEVER(8); NULLMAYBE(9, 0x10); NULLMAYBE(10, 0x20); #undef NULLMAYBE #undef NULLNEVER } ASSERT_EQ(cur_row, table_size); drizzle_result_free(result); #ifdef TEST_PREPARED_STATEMENTS strcpy(querybuf, "select a,b,c,d,e,f,g,h,i,j,k from test_nulls.t1 order by e"); sth = drizzle_stmt_prepare(con, querybuf, strlen(querybuf), &driz_ret); ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, preparing \"%s\"", drizzle_strerror(driz_ret), drizzle_error(con), querybuf); driz_ret = drizzle_stmt_execute(sth); ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, executing \"%s\"", drizzle_strerror(driz_ret), drizzle_error(con), querybuf); cur_row = 0; for (;;) { driz_ret = drizzle_stmt_fetch(sth); if (driz_ret == DRIZZLE_RETURN_ROW_END) break; cur_row ++; ASSERT_EQ_(driz_ret, DRIZZLE_RETURN_OK, "Error (%s): %s, fetching row #%d", drizzle_strerror(driz_ret), drizzle_error(con), cur_row); /* 'sym' is the value used to decide which fields have NULLs or not. * 'rowbase' is the number that would be stored in the first field of this * row (assuming it's non-NULL). */ int sym, rowbase; if (cur_row <= 64) { sym = cur_row - 1; rowbase = sym*NCOLS; } else { sym = cur_row - 65; rowbase = 1000 + sym*NCOLS; } bool isNull; uint32_t rowvalue; #define GETNULLNESS(cn) isNull = drizzle_stmt_get_is_null(sth, cn, &driz_ret); ASSERT_EQ(driz_ret, DRIZZLE_RETURN_OK); #define NULLNOTNOW(cn) ASSERT_FALSE_(isNull, "Column %d, row %d should not be NULL", cn+1, cur_row); rowvalue = drizzle_stmt_get_int(sth, cn, &driz_ret); ASSERT_EQ(driz_ret,DRIZZLE_RETURN_OK); ASSERT_EQ_(rowvalue, (unsigned)(rowbase + cn), "Column %d, row %d has unexpected data, expected: %d, got: %d", cn+1, cur_row, rowbase+cn, rowvalue); #define NULLMAYBE(cn, b) GETNULLNESS(cn); if (sym & b) { ASSERT_TRUE_(isNull, "Column %d, row %d should be NULL", cn+1, cur_row); } else { NULLNOTNOW(cn); } #define NULLNEVER(cn) GETNULLNESS(cn); NULLNOTNOW(cn); NULLMAYBE(0, 0x01); NULLMAYBE(1, 0x02); NULLMAYBE(2, 0x04); NULLNEVER(3); NULLNEVER(4); NULLNEVER(5); NULLNEVER(6); NULLMAYBE(7, 0x08); NULLNEVER(8); NULLMAYBE(9, 0x10); NULLMAYBE(10, 0x20); #undef NULLMAYBE #undef NULLNEVER #undef GETNULLNESS #undef NULLNOTNOW } ASSERT_EQ_(cur_row, table_size, "Current row not equal to table size, expected %d, got %d", table_size, cur_row); ASSERT_EQ(drizzle_stmt_close(sth), DRIZZLE_RETURN_OK); #endif CHECKED_QUERY("DROP TABLE test_nulls.t1"); ASSERT_EQ_(DRIZZLE_RETURN_OK, driz_ret, "DROP TABLE test_nulls.t1"); CHECKED_QUERY("DROP SCHEMA IF EXISTS test_nulls"); driz_ret= drizzle_quit(con); ASSERT_EQ_(DRIZZLE_RETURN_OK, driz_ret, "%s", drizzle_strerror(driz_ret)); free(querybuf); return EXIT_SUCCESS; }
void drizzle_result_free_all(drizzle_con_st *con) { while (con->result_list != NULL) drizzle_result_free(con->result_list); }
ngx_int_t ngx_http_drizzle_output_result_header(ngx_http_request_t *r, drizzle_result_st *res) { u_char *pos, *last; ngx_int_t rc; ngx_http_upstream_t *u = r->upstream; const char *errstr; size_t size; uint16_t errstr_len; uint16_t col_count; uint16_t errcode; ngx_http_upstream_drizzle_peer_data_t *dp = u->peer.data; errcode = drizzle_result_error_code(res); if (dp->enable_charset && ! dp->has_set_names) { if (errcode != 0) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "drizzle: FATAL: failed to set names 'utf8' " "(error %d)", (int) errcode); return NGX_ERROR; } if (dp->drizzle_con && dp->drizzle_res.con) { dd("before drizzle result free"); dd("%p vs. %p", dp->drizzle_res.con, dp->drizzle_con); drizzle_result_free(&dp->drizzle_res); dd("after drizzle result free"); } /* ngx_http_upstream_drizzle_done(r, u, dp, NGX_OK); */ dd("returning DONE when set names"); return NGX_DONE; } errstr = drizzle_result_error(res); errstr_len = (uint16_t) ngx_strlen(errstr); col_count = drizzle_result_column_count(res); size = sizeof(uint8_t) /* endian type */ + sizeof(uint32_t) /* format version */ + sizeof(uint8_t) /* result type */ + sizeof(uint16_t) /* standard error code */ + sizeof(uint16_t) /* driver-specific error code */ + sizeof(uint16_t) /* driver-specific errstr len */ + errstr_len /* driver-specific errstr data */ + sizeof(uint64_t) /* rows affected */ + sizeof(uint64_t) /* insert id */ + sizeof(uint16_t); /* column count */ pos = ngx_http_drizzle_request_mem(r, dp, size); if (pos == NULL) { return NGX_ERROR; } last = pos; #if NGX_HAVE_LITTLE_ENDIAN *last++ = 0; #else /* big endian */ *last++ = 1; #endif /* RDS format version */ *(uint32_t *) last = (uint32_t) resty_dbd_stream_version; last += sizeof(uint32_t); /* result type fixed to 0 */ *last++ = 0; /* standard error code * FIXME: define the standard error code set and map * libdrizzle's to it. */ *(uint16_t *) last = errcode; last += sizeof(uint16_t); /* driver-specific error code */ *(uint16_t *) last = drizzle_result_error_code(res); last += sizeof(uint16_t); /* driver-specific errstr len */ *(uint16_t *) last = errstr_len; last += sizeof(uint16_t); /* driver-specific errstr data */ if (errstr_len) { last = ngx_copy(last, (u_char *) errstr, errstr_len); } /* affected rows */ *(uint64_t *) last = drizzle_result_affected_rows(res); last += sizeof(uint64_t); /* insert id */ *(uint64_t *) last = drizzle_result_insert_id(res); last += sizeof(uint64_t); /* column count */ *(uint16_t *) last = col_count; last += sizeof(uint16_t); if ((size_t) (last - pos) != size) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "drizzle: FATAL: output result header buffer error"); return NGX_ERROR; } if (col_count == 0) { dd("Col count is ZERO"); /* we suppress row terminator here when there's no columns */ dp->seen_stream_end = 1; rc = ngx_http_drizzle_submit_mem(r, dp, size); if (rc != NGX_OK) { return NGX_ERROR; } dd("about to be done..."); ngx_http_upstream_drizzle_done(r, u, dp, NGX_DONE); dd("i am returning DONE"); return NGX_DONE; } return ngx_http_drizzle_submit_mem(r, dp, size); }
static void server(drizzle_st *drizzle, drizzle_con_st *con, drizzle_result_st *result, drizzle_column_st *column) { drizzle_return_t ret; drizzle_command_t command; uint8_t *data= NULL; size_t total; char *field[2]; char field1[DRIZZLE_FIELD_MAX]; char field2[DRIZZLE_FIELD_MAX]; size_t size[2]; uint64_t x; field[0]= field1; field[1]= field2; /* Handshake packets. */ drizzle_con_set_protocol_version(con, 10); drizzle_con_set_server_version(con, "libdrizzle example 1.2.3"); drizzle_con_set_thread_id(con, 1); drizzle_con_set_scramble(con, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST"); drizzle_con_set_capabilities(con, DRIZZLE_CAPABILITIES_NONE); drizzle_con_set_charset(con, 8); drizzle_con_set_status(con, DRIZZLE_CON_STATUS_NONE); drizzle_con_set_max_packet_size(con, DRIZZLE_MAX_PACKET_SIZE); ret= drizzle_handshake_server_write(con); DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_server_write", drizzle) ret= drizzle_handshake_client_read(con); DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", drizzle) if (drizzle_result_create(con, result) == NULL) DRIZZLE_RETURN_ERROR("drizzle_result_create", drizzle) ret= drizzle_result_write(con, result, true); DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle) /* Command loop. */ while (1) { drizzle_result_free(result); if (data != NULL) free(data); data= drizzle_con_command_buffer(con, &command, &total, &ret); if (ret == DRIZZLE_RETURN_LOST_CONNECTION || (ret == DRIZZLE_RETURN_OK && command == DRIZZLE_COMMAND_QUIT)) { if (data != NULL) free(data); return; } DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", drizzle) if (drizzle_result_create(con, result) == NULL) DRIZZLE_RETURN_ERROR("drizzle_result_create", drizzle) if (command != DRIZZLE_COMMAND_QUERY) { ret= drizzle_result_write(con, result, true); DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle) continue; } drizzle_result_set_column_count(result, 2); ret= drizzle_result_write(con, result, false); DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle) /* Columns. */ if (drizzle_column_create(result, column) == NULL) DRIZZLE_RETURN_ERROR("drizzle_column_create", drizzle) drizzle_column_set_catalog(column, "default"); drizzle_column_set_db(column, "drizzle_test_db"); drizzle_column_set_table(column, "drizzle_test_table"); drizzle_column_set_orig_table(column, "drizzle_test_table"); drizzle_column_set_name(column, "test_column_1"); drizzle_column_set_orig_name(column, "test_column_1"); drizzle_column_set_charset(column, 8); drizzle_column_set_size(column, DRIZZLE_FIELD_MAX); drizzle_column_set_type(column, DRIZZLE_COLUMN_TYPE_VARCHAR); ret= drizzle_column_write(result, column); DRIZZLE_RETURN_CHECK(ret, "drizzle_column_write", drizzle) drizzle_column_set_name(column, "test_column_2"); drizzle_column_set_orig_name(column, "test_column_2"); ret= drizzle_column_write(result, column); DRIZZLE_RETURN_CHECK(ret, "drizzle_column_write", drizzle) drizzle_column_free(column); drizzle_result_set_eof(result, true); ret= drizzle_result_write(con, result, false); DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle) /* Rows. */ for (x= 0; x < DRIZZLE_RESULT_ROWS; x++) { size[0]= (size_t)snprintf(field[0], DRIZZLE_FIELD_MAX, "field %" PRIu64 "-1", x); if (size[0] >= DRIZZLE_FIELD_MAX) size[0]= DRIZZLE_FIELD_MAX - 1; size[1]= (size_t)snprintf(field[1], DRIZZLE_FIELD_MAX, "field %" PRIu64 "-2", x); if (size[1] >= DRIZZLE_FIELD_MAX) size[1]= DRIZZLE_FIELD_MAX - 1; /* This is needed for MySQL and old Drizzle protocol. */ drizzle_result_calc_row_size(result, (drizzle_field_t *)field, size); ret= drizzle_row_write(result); DRIZZLE_RETURN_CHECK(ret, "drizzle_row_write", drizzle) /* Fields. */ ret= drizzle_field_write(result, (drizzle_field_t)field[0], size[0], size[0]); DRIZZLE_RETURN_CHECK(ret, "drizzle_field_write", drizzle) ret= drizzle_field_write(result, (drizzle_field_t)field[1], size[1], size[1]); DRIZZLE_RETURN_CHECK(ret, "drizzle_field_write", drizzle) } ret= drizzle_result_write(con, result, true); DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", drizzle) }