C++ (Cpp) ib_tuple_read_u64 Examples

Example #1

File: test0aux.c Project: nealrichter/memcache_innodb

void
print_int_col(
/*==========*/
	FILE*		stream,
	const ib_tpl_t	tpl,
	int		i,
	ib_col_meta_t*	col_meta)
{
	ib_err_t	err = DB_SUCCESS;

	switch (col_meta->type_len) {
	case 1: {
		if (col_meta->attr & IB_COL_UNSIGNED) {
			ib_u8_t		u8;

			err = ib_tuple_read_u8(tpl, i, &u8);
			fprintf(stream, "%u", u8);
		} else {
			ib_i8_t		i8;

			err = ib_tuple_read_i8(tpl, i, &i8);
			fprintf(stream, "%d", i8);
		}
		break;
	}
	case 2: {
		if (col_meta->attr & IB_COL_UNSIGNED) {
			ib_u16_t	u16;

			err = ib_tuple_read_u16(tpl, i, &u16);
			fprintf(stream, "%u", u16);
		} else {
			ib_i16_t	i16;

			err = ib_tuple_read_i16(tpl, i, &i16);
			fprintf(stream, "%d", i16);
		}
		break;
	}
	case 4: {
		if (col_meta->attr & IB_COL_UNSIGNED) {
			ib_u32_t	u32;

			err = ib_tuple_read_u32(tpl, i, &u32);
			fprintf(stream, "%u", u32);
		} else {
			ib_i32_t	i32;

			err = ib_tuple_read_i32(tpl, i, &i32);
			fprintf(stream, "%d", i32);
		}
		break;
	}
	case 8: {
		if (col_meta->attr & IB_COL_UNSIGNED) {
			ib_u64_t	u64;

			err = ib_tuple_read_u64(tpl, i, &u64);
			fprintf(stream, "%lu", u64);
		} else {
			ib_i64_t	i64;

			err = ib_tuple_read_i64(tpl, i, &i64);
			fprintf(stream, "%ld",  i64);
		}
		break;
	}
	default:
		assert(0);
		break;
	}
	assert(err == DB_SUCCESS);
}

Example #2

File: storage_innodb.c Project: Lucky7Studio/libmemcached

/**
 * Try to get an item from the database
 *
 * @param trx the transaction to use
 * @param key the key to get
 * @param nkey the lenght of the key
 * @return a pointer to the item if I found it in the database
 */
static struct item* do_get_item(ib_trx_t trx, const void* key, size_t nkey) 
{
  ib_crsr_t cursor= NULL;
  ib_tpl_t tuple= NULL;
  struct item* retval= NULL;

  if (do_locate_item(trx, key, nkey, &cursor)) 
  {
    tuple= ib_clust_read_tuple_create(cursor);
    if (tuple == NULL)
    {
      fprintf(stderr, "Failed to create read tuple\n");
      goto error_exit;
    }
    checked(ib_cursor_read_row(cursor, tuple));
    ib_col_meta_t meta;
    ib_ulint_t datalen= ib_col_get_meta(tuple, data_col_idx, &meta);
    ib_ulint_t flaglen= ib_col_get_meta(tuple, flags_col_idx, &meta);
    ib_ulint_t caslen= ib_col_get_meta(tuple, cas_col_idx, &meta);
    ib_ulint_t explen= ib_col_get_meta(tuple, exp_col_idx, &meta);
    const void *dataptr= ib_col_get_value(tuple, data_col_idx);

    retval= create_item(key, nkey, dataptr, datalen, 0, 0);
    if (retval == NULL) 
    {
      fprintf(stderr, "Failed to allocate memory\n");
      goto error_exit;
    }

    if (flaglen != 0) 
    {
      ib_u32_t val;
      checked(ib_tuple_read_u32(tuple, flags_col_idx, &val));
      retval->flags= (uint32_t)val;
    }
    if (caslen != 0) 
    {
      ib_u64_t val;
      checked(ib_tuple_read_u64(tuple, cas_col_idx, &val));
      retval->cas= (uint64_t)val;
    }
    if (explen != 0) 
    {
      ib_u32_t val;
      checked(ib_tuple_read_u32(tuple, exp_col_idx, &val));
      retval->exp= (time_t)val;
    }
  }

  /* Release resources */
  /* FALLTHROUGH */

 error_exit:
  if (tuple != NULL)
    ib_tuple_delete(tuple);

  if (cursor != NULL)
  {
    ib_err_t cursor_error;
    cursor_error= ib_cursor_close(cursor);
    (void) cursor_error;
  }

  return retval;
}