long long dbi_result_get_longlong_idx(dbi_result Result, unsigned int fieldidx) {
long long ERROR = 0;
fieldidx--;
RESULT->conn->error_flag = DBI_ERROR_NONE;
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return ERROR;
}
if (RESULT->field_types[fieldidx] != DBI_TYPE_INTEGER) {
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
_verbose_handler(RESULT->conn, "%s: field `%s` is not integer type\n",
__func__, dbi_result_get_field_name(Result, fieldidx+1));
return ERROR;
}
switch (RESULT->field_attribs[fieldidx] & DBI_INTEGER_SIZEMASK) {
case DBI_INTEGER_SIZE1:
case DBI_INTEGER_SIZE2:
case DBI_INTEGER_SIZE3:
case DBI_INTEGER_SIZE4:
case DBI_INTEGER_SIZE8:
return RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_longlong;
default:
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
return ERROR;
}
}
static int _setup_binding(dbi_result_t *result, const char *fieldname, void *bindto, void *helperfunc) {
_field_binding_t *binding;
if (!result) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return DBI_BIND_ERROR;
}
else if (!fieldname) {
_error_handler(result->conn, DBI_ERROR_BADNAME);
return DBI_BIND_ERROR;
}
binding = _find_or_create_binding_node(result, fieldname);
if (!binding) {
_error_handler(result->conn, DBI_ERROR_NOMEM);
return DBI_BIND_ERROR;
}
if (bindto == NULL) {
_remove_binding_node(result, binding);
}
else {
binding->bindto = bindto;
binding->helper_function = (void*)(_field_binding_t *)helperfunc;
}
return 0;
}
unsigned char *dbi_result_get_binary_copy_idx(dbi_result Result, unsigned int fieldidx) {
char *ERROR = "ERROR";
unsigned char *newblob = NULL;
unsigned long long size;
fieldidx--;
RESULT->conn->error_flag = DBI_ERROR_NONE;
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return (unsigned char *)strdup(ERROR);
}
if (RESULT->field_types[fieldidx] != DBI_TYPE_BINARY) {
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
_verbose_handler(RESULT->conn, "%s: field `%s` is not binary type\n",
__func__, dbi_result_get_field_name(Result, fieldidx+1));
return (unsigned char *)strdup(ERROR);
}
if (RESULT->rows[RESULT->currowidx]->field_sizes[fieldidx] == 0) return NULL;
size = dbi_result_get_field_size_idx(Result, fieldidx);
newblob = malloc(size);
if (!newblob) {
_error_handler(RESULT->conn, DBI_ERROR_NOMEM);
return (unsigned char *)strdup(ERROR);
}
memcpy(newblob, RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_string, size);
return newblob;
}
int dbi_conn_select_db(dbi_conn Conn, const char *db) {
dbi_conn_t *conn = Conn;
const char *retval;
if (!conn || !(conn->connection)) return -1;
_reset_conn_error(conn);
if (conn->current_db) free(conn->current_db);
conn->current_db = NULL;
retval = conn->driver->functions->select_db(conn, db);
if (retval == NULL) {
_error_handler(conn, DBI_ERROR_DBD);
return -1;
}
if (*retval == '\0') {
/* if "" was returned, conn doesn't support switching databases */
_error_handler(conn, DBI_ERROR_UNSUPPORTED);
return -1;
}
else {
conn->current_db = strdup(retval);
}
return 0;
}
size_t dbi_conn_quote_string_copy(dbi_conn Conn, const char *orig, char **newquoted) {
dbi_conn_t *conn = Conn;
char *newstr;
size_t newlen;
if (!conn) {
return 0;
}
_reset_conn_error(conn);
if (!orig || !newquoted) {
_error_handler(conn, DBI_ERROR_BADPTR);
return 0;
}
newstr = malloc((strlen(orig)*2)+4+1); /* worst case, we have to escape every character and add 2*2 surrounding quotes */
if (!newstr) {
_error_handler(conn, DBI_ERROR_NOMEM);
return 0;
}
newlen = conn->driver->functions->conn_quote_string(conn, orig, newstr);
if (!newlen) {
free(newstr);
_error_handler(conn, DBI_ERROR_NOMEM);
return 0;
}
*newquoted = newstr;
return newlen;
}
char *dbi_result_get_string_copy_idx(dbi_result Result, unsigned int fieldidx) {
char *ERROR = "ERROR";
char *newstring = NULL;
fieldidx--;
RESULT->conn->error_flag = DBI_ERROR_NONE;
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return strdup(ERROR);
}
if (RESULT->field_types[fieldidx] != DBI_TYPE_STRING) {
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
_verbose_handler(RESULT->conn, "%s: field `%s` is not string type\n",
__func__, dbi_result_get_field_name(Result, fieldidx+1));
return strdup(ERROR);
}
if (RESULT->rows[RESULT->currowidx]->field_sizes[fieldidx] == 0
&& RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_string == NULL) {
// mysql returns 0 for the field size of an empty string, so size==0
// doesn't necessarily mean NULL
return NULL;
}
newstring = strdup(RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_string);
if (newstring) {
return newstring;
}
else {
_error_handler(RESULT->conn, DBI_ERROR_NOMEM);
return strdup(ERROR);
}
}
size_t dbi_conn_quote_binary_copy(dbi_conn Conn, const unsigned char *orig, size_t from_length, unsigned char **ptr_dest) {
unsigned char *temp = NULL;
size_t newlen;
dbi_conn_t *conn = Conn;
if (!conn) {
return 0;
}
_reset_conn_error(conn);
if (!orig || !ptr_dest) {
_error_handler(conn, DBI_ERROR_BADPTR);
return 0;
}
newlen = conn->driver->functions->quote_binary(conn, orig, from_length, &temp);
if (!newlen) {
_error_handler(conn, DBI_ERROR_NOMEM);
return 0;
}
*ptr_dest = temp;
return newlen;
}
const char *dbi_result_get_string_idx(dbi_result Result, unsigned int fieldidx) {
const char *ERROR = "ERROR";
fieldidx--;
RESULT->conn->error_flag = DBI_ERROR_NONE;
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return ERROR;
}
if (RESULT->field_types[fieldidx] != DBI_TYPE_STRING) {
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
_verbose_handler(RESULT->conn, "%s: field `%s` is not string type\n",
__func__, dbi_result_get_field_name(Result, fieldidx+1));
return ERROR;
}
if (RESULT->rows[RESULT->currowidx]->field_sizes[fieldidx] == 0
&& _get_field_flag(RESULT->rows[RESULT->currowidx], fieldidx, DBI_VALUE_NULL)) {
/* string does not exist */
return NULL;
}
/* else if field size == 0: empty string */
return (const char *)(RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_string);
}
double dbi_result_get_double_idx(dbi_result Result, unsigned int fieldidx) {
double ERROR = 0.0;
fieldidx--;
RESULT->conn->error_flag = DBI_ERROR_NONE;
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return ERROR;
}
if (RESULT->field_types[fieldidx] != DBI_TYPE_DECIMAL) {
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
_verbose_handler(RESULT->conn, "%s: field `%s` is not double type\n",
__func__, dbi_result_get_field_name(Result, fieldidx+1));
return ERROR;
}
switch (RESULT->field_attribs[fieldidx] & DBI_DECIMAL_SIZEMASK) {
case DBI_DECIMAL_SIZE4:
case DBI_DECIMAL_SIZE8:
return RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_double;
default:
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
return ERROR;
}
}
int dbi_result_prev_row(dbi_result Result) {
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return 0;
}
if (!dbi_result_has_prev_row(Result)) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return 0;
}
return dbi_result_seek_row(Result, RESULT->currowidx-1);
}
const char *dbi_conn_get_option_list(dbi_conn Conn, const char *current) {
dbi_conn_t *conn = Conn;
dbi_option_t *option;
if (!conn) {
return NULL;
}
_reset_conn_error(conn);
if (!conn->options) {
_error_handler(conn, DBI_ERROR_BADPTR);
return NULL;
}
option = conn->options;
if (!current) {
return option->key;
}
else {
while (option && strcasecmp(current, option->key)) {
option = option->next;
}
/* return NULL if there are no more options but don't make
this an error */
return (option && option->next) ? option->next->key : NULL;
}
}
size_t dbi_conn_quote_string(dbi_conn Conn, char **orig) {
dbi_conn_t *conn = Conn;
char *temp = NULL;
char *newstr = NULL;
size_t newlen;
if (!conn) {
return 0;
}
_reset_conn_error(conn);
if (!orig || !*orig) {
_error_handler(conn, DBI_ERROR_BADPTR);
return 0;
}
newlen = dbi_conn_quote_string_copy(Conn, *orig, &newstr);
if (!newlen) {
/* leave original string alone in case of an error */
/* error number was set by called function */
return 0;
}
temp = *orig;
*orig = newstr;
free(temp); /* original unescaped string */
return newlen;
}
int dbi_result_free(dbi_result Result) {
int retval = 0;
if (!RESULT) return -1;
if (RESULT->conn) {
retval = _disjoin_from_conn(RESULT);
}
while (RESULT->field_bindings) {
_remove_binding_node(RESULT, RESULT->field_bindings);
}
if (RESULT->rows) {
_free_result_rows(RESULT);
}
if (RESULT->numfields) {
_free_string_list(RESULT->field_names, RESULT->numfields);
free(RESULT->field_types);
free(RESULT->field_attribs);
}
if (retval == -1) {
_error_handler(RESULT->conn, DBI_ERROR_DBD);
}
free(RESULT);
return retval;
}
unsigned long long dbi_result_get_currow(dbi_result Result) {
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return 0;
}
return RESULT->currowidx;
}
int dbi_result_has_prev_row(dbi_result Result) {
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return 0;
}
return RESULT->result_state != NOTHING_RETURNED && RESULT->currowidx > 1;
}
int dbi_result_field_is_null(dbi_result Result, const char *fieldname) {
unsigned int fieldidx = 0;
dbi_error_flag errflag;
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return DBI_FIELD_FLAG_ERROR;
}
fieldidx = _find_field(RESULT, fieldname, &errflag);
if (errflag != DBI_ERROR_NONE) {
_error_handler(RESULT->conn, errflag);
return DBI_FIELD_FLAG_ERROR;
}
return dbi_result_field_is_null_idx(Result, fieldidx+1);
}
unsigned long long dbi_result_get_numrows_affected(dbi_result Result) {
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return DBI_ROW_ERROR;
}
return RESULT->numrows_affected;
}
unsigned int dbi_result_get_field_attribs(dbi_result Result, const char *fieldname) {
unsigned int fieldidx = 0;
dbi_error_flag errflag;
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return DBI_ATTRIBUTE_ERROR;
}
fieldidx = _find_field(RESULT, fieldname, &errflag);
if (errflag != DBI_ERROR_NONE) {
_error_handler(RESULT->conn, errflag);
return DBI_ATTRIBUTE_ERROR;
}
return dbi_result_get_field_attribs_idx(Result, fieldidx+1);
}
const char *dbi_result_get_field_name(dbi_result Result, unsigned int fieldidx) {
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return NULL;
}
else if (fieldidx > RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return NULL;
}
else if (RESULT->field_names == NULL) {
_error_handler(RESULT->conn, DBI_ERROR_BADOBJECT);
return NULL;
}
return (const char *) RESULT->field_names[fieldidx-1];
}
dbi_conn dbi_result_get_conn(dbi_result Result) {
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return NULL;
}
return RESULT->conn;
}
unsigned int dbi_result_get_field_attribs_idx(dbi_result Result, unsigned int fieldidx) {
fieldidx--;
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return DBI_ATTRIBUTE_ERROR;
}
else if (!RESULT->field_attribs) {
_error_handler(RESULT->conn, DBI_ERROR_BADOBJECT);
return DBI_ATTRIBUTE_ERROR;
}
else if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return DBI_ATTRIBUTE_ERROR;
}
return RESULT->field_attribs[fieldidx];
}
int dbi_result_has_next_row(dbi_result Result) {
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return 0;
}
return RESULT->result_state != NOTHING_RETURNED
&& RESULT->currowidx < dbi_result_get_numrows(Result);
}
unsigned int dbi_result_get_field_idx(dbi_result Result, const char *fieldname) {
unsigned int fieldidx = 0;
dbi_error_flag errflag;
if (!RESULT) {
_error_handler(/*RESULT->conn*/ NULL, DBI_ERROR_BADPTR);
return 0;
}
/* user-visible indexes start at 1 */
fieldidx = _find_field(RESULT, fieldname, &errflag)+1;
if (errflag != DBI_ERROR_NONE) {
_error_handler(RESULT->conn, errflag);
return 0;
}
return fieldidx;
}
time_t dbi_result_get_datetime_idx(dbi_result Result, unsigned int fieldidx) {
time_t ERROR = 0;
fieldidx--;
RESULT->conn->error_flag = DBI_ERROR_NONE;
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return ERROR;
}
if (RESULT->field_types[fieldidx] != DBI_TYPE_DATETIME) {
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
_verbose_handler(RESULT->conn, "%s: field `%s` is not datetime type\n",
__func__, dbi_result_get_field_name(Result, fieldidx+1));
return ERROR;
}
return (time_t)(RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_datetime);
}
const unsigned char *dbi_result_get_binary_idx(dbi_result Result, unsigned int fieldidx) {
const char *ERROR = "ERROR";
fieldidx--;
RESULT->conn->error_flag = DBI_ERROR_NONE;
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return (const unsigned char*)ERROR;
}
if (RESULT->field_types[fieldidx] != DBI_TYPE_BINARY) {
_error_handler(RESULT->conn, DBI_ERROR_BADTYPE);
_verbose_handler(RESULT->conn, "%s: field `%s` is not binary type\n",
__func__, dbi_result_get_field_name(Result, fieldidx+1));
return (const unsigned char*)ERROR;
}
if (RESULT->rows[RESULT->currowidx]->field_sizes[fieldidx] == 0) return NULL;
return (const unsigned char *)(RESULT->rows[RESULT->currowidx]->field_values[fieldidx].d_string);
}
unsigned char *dbi_result_get_binary_copy(dbi_result Result, const char *fieldname) {
char *ERROR = "ERROR";
unsigned int fieldidx;
dbi_error_flag errflag;
fieldidx = _find_field(RESULT, fieldname, &errflag);
if (errflag != DBI_ERROR_NONE) {
dbi_conn_t *conn = RESULT->conn;
_error_handler(conn, DBI_ERROR_BADNAME);
return (unsigned char *)strdup(ERROR);
}
return dbi_result_get_binary_copy_idx(Result, fieldidx+1);
}
float dbi_result_get_float(dbi_result Result, const char *fieldname) {
float ERROR = 0.0;
dbi_error_flag errflag;
unsigned int fieldidx;
fieldidx = _find_field(RESULT, fieldname, &errflag);
if (errflag != DBI_ERROR_NONE) {
dbi_conn_t *conn = RESULT->conn;
_error_handler(conn, DBI_ERROR_BADNAME);
return ERROR;
}
return dbi_result_get_float_idx(Result, fieldidx+1);
}
signed char dbi_result_get_char(dbi_result Result, const char *fieldname) {
signed char ERROR = 0;
unsigned int fieldidx;
dbi_error_flag errflag;
fieldidx = _find_field(RESULT, fieldname, &errflag);
if (errflag != DBI_ERROR_NONE) {
dbi_conn_t *conn = RESULT->conn;
_error_handler(conn, errflag);
return ERROR;
}
return dbi_result_get_char_idx(Result, fieldidx+1);
}
int dbi_result_field_is_null_idx(dbi_result Result, unsigned int fieldidx) {
unsigned long long currowidx;
fieldidx--;
if (!RESULT || !RESULT->rows) {
_error_handler(RESULT ? RESULT->conn : NULL, DBI_ERROR_BADPTR);
return DBI_FIELD_FLAG_ERROR;
}
currowidx = RESULT->currowidx;
if (!RESULT->rows[currowidx] || !RESULT->rows[currowidx]->field_flags) {
_error_handler(RESULT->conn, DBI_ERROR_BADOBJECT);
return DBI_FIELD_FLAG_ERROR;
}
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return DBI_FIELD_FLAG_ERROR;
}
return _get_field_flag(RESULT->rows[currowidx], fieldidx, DBI_VALUE_NULL);
}
size_t dbi_result_get_field_length_idx(dbi_result Result, unsigned int fieldidx) {
unsigned long long currowidx;
/* user-visible indexes start at 1 */
fieldidx--;
if (!RESULT || !RESULT->rows) {
_error_handler(RESULT ? RESULT->conn : NULL, DBI_ERROR_BADPTR);
return DBI_LENGTH_ERROR;
}
currowidx = RESULT->currowidx;
if (!RESULT->rows[currowidx] || !RESULT->rows[currowidx]->field_sizes) {
_error_handler(RESULT->conn, DBI_ERROR_BADOBJECT);
return DBI_LENGTH_ERROR;
}
if (fieldidx >= RESULT->numfields) {
_error_handler(RESULT->conn, DBI_ERROR_BADIDX);
return DBI_LENGTH_ERROR;
}
return RESULT->rows[currowidx]->field_sizes[fieldidx];
}
