bool init_db(void)
{
ib_err_t err;
/* Initialize the memory sub-system. */
ib_init();
/* Call the ib_cfg_*() functions to setup the directory etc. */
err = ib_cfg_set_bool_off("adaptive_hash_index");
err = ib_cfg_set_int("additional_mem_pool_size", 16*1024*1024);
err = ib_cfg_set_int("buffer_pool_size", 1024*1024*1024);
err = ib_cfg_set_int("flush_log_at_trx_commit", 2);
err = ib_cfg_set_int("log_buffer_size", 8*1024*1024);
err = ib_cfg_set_int("log_file_size", 256*1024*1024);
err = ib_cfg_set_text("data_home_dir", "/data/");
err = ib_cfg_set_text("log_group_home_dir", "/data/");
err = ib_cfg_set_text("flush_method", "O_DIRECT");
/* Create system files if this is the first time
* or do recovery if starting an existing instance. */
err = ib_startup("barracuda");
/* File format "barracuda" supports all
* the currently available table formats. */
if (err == DB_SUCCESS) {
printf("InnoDB started!\n");
} else {
printf("Error starting up InnoDB: %s\n", ib_strerror(err));
return false;
}
return true;
}
/**
* Initialize the database storage
* @return true if the database was initialized successfully, false otherwise
*/
bool initialize_storage(void)
{
ib_err_t error;
ib_id_t tid;
checked(ib_init());
checked(ib_cfg_set_text("data_home_dir", "/tmp/memcached_light"));
checked(ib_cfg_set_text("log_group_home_dir", "/tmp/memcached_light"));
checked(ib_cfg_set_bool_on("file_per_table"));
checked(ib_startup("barracuda"));
/* check to see if the table exists or if we should create the schema */
error= ib_table_get_id(tablename, &tid);
if (error == DB_TABLE_NOT_FOUND)
{
if (!create_schema())
{
return false;
}
}
else if (error != DB_SUCCESS)
{
fprintf(stderr, "Failed to get table id: %s\n", ib_strerror(error));
return false;
}
return true;
error_exit:
return false;
}
int main(int argc, char* argv[])
{
int i;
ib_err_t err;
ib_crsr_t crsr;
ib_trx_t ib_trx;
(void) argc;
(void) argv;
err = ib_init();
assert(err == DB_SUCCESS);
test_configure();
err = ib_startup("barracuda");
assert(err == DB_SUCCESS);
err = create_database(DATABASE);
assert(err == DB_SUCCESS);
/* Create the tables. */
for (i = 0; i < 10; i++) {
err = create_table(DATABASE, TABLE, i);
assert(err == DB_SUCCESS);
}
ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
assert(ib_trx != NULL);
/* Open and close the cursor. */
for (i = 0; i < 10; i++) {
err = open_table(DATABASE, TABLE, i, ib_trx, &crsr);
assert(err == DB_SUCCESS);
err = ib_cursor_close(crsr);
assert(err == DB_SUCCESS);
crsr = NULL;
}
err = ib_trx_commit(ib_trx);
assert(err == DB_SUCCESS);
err = ib_database_drop(DATABASE);
assert(err == DB_SUCCESS);
err = ib_shutdown(IB_SHUTDOWN_NORMAL);
assert(err == DB_SUCCESS);
#ifdef UNIV_DEBUG_VALGRIND
VALGRIND_DO_LEAK_CHECK;
#endif
return(EXIT_SUCCESS);
}
/*
* Returns a completely-allocated prod_info. "Completely-allocated" means that
* the "origin" and "ident" members point to buffers sufficient to hold any
* valid value. The members are initialized as follows:
* arrival: TS_NONE
* feedtype: NONE
* seqno: 0
* sz: 0
* origin: ""
* ident: ""
* signature: {0}
*
* Returns:
* NULL Failure. errno is set.
* else A completely-allocated prod_info.
*/
prod_info*
pi_new(void)
{
prod_info* info = NULL; /* failure */
InfoBuf* buf = (InfoBuf*)malloc(sizeof(InfoBuf));
if (NULL != buf)
info = ib_init(buf);
return info;
}
int main(int argc, char* argv[])
{
ib_err_t err;
(void) argc;
(void) argv;
err = ib_init();
assert(err == DB_SUCCESS);
test_configure();
ib_logger_set(null_logger, NULL);
err = ib_startup("barracuda");
assert(err == DB_SUCCESS);
err = ib_shutdown(IB_SHUTDOWN_NORMAL);
assert(err == DB_SUCCESS);
return(EXIT_SUCCESS);
}
int main(int argc, char* argv[])
{
ib_err_t err;
print_version();
err = ib_init();
assert(err == DB_SUCCESS);
test_configure();
#ifndef __WIN__
set_options(argc, argv);
#endif
err = ib_startup("barracuda");
assert(err == DB_SUCCESS);
err = test_phase_I();
if (err == DB_SUCCESS) {
restart(argc, argv);
/* Shouldn't get here. */
abort();
} else {
/* Recovery was successful. */
assert(err == DB_DUPLICATE_KEY);
err = drop_table(DATABASE, TABLE);
assert(err == DB_SUCCESS);
err = ib_shutdown(IB_SHUTDOWN_NORMAL);
assert(err == DB_SUCCESS);
}
return(EXIT_SUCCESS);
}
static int innostore_drv_init()
{
char log_filename[_POSIX_PATH_MAX];
size_t log_filename_size = sizeof(log_filename);
ErlDrvSysInfo sys_info;
G_ENGINE_STATE_LOCK = erl_drv_mutex_create("innostore_state_lock");
G_LOGGER_LOCK = erl_drv_mutex_create("innostore_logger_lock");
// Check if this is beam.smp - cannot run under beam
// due to restrictions with driver_send_term
driver_system_info(&sys_info, sizeof(sys_info));
if (sys_info.smp_support == 0)
{
log("Innostore only supports the SMP runtime, add -smp enable");
return -1;
}
// Initialize Inno's memory subsystem
if (ib_init() != DB_SUCCESS)
{
return -1;
}
// Set up the logger
if (erl_drv_getenv("INNOSTORE_LOG", log_filename, &log_filename_size) == 0)
{
set_log_file(log_filename);
}
else
{
set_log_file(NULL);
}
return 0;
}
int main(int argc,char **argv){
if(argc != 2){
printf("give me a database\table name\n");
return 1;
}
char *dtname=argv[1];
ib_err_t err;
err=ib_init();
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_int("log_buffer_size", 8*1024*1024);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_int("force_recovery", 1);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_int("log_file_size", 128*1024*1024);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_int("log_files_in_group", 3);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_text("log_group_home_dir", "./");
//err = ib_cfg_set_text("log_group_home_dir", "/var/lib/mysql/");
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_text("data_home_dir", "./");
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_text("data_file_path", "ibdata1:500M:autoextend");
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err = ib_cfg_set_bool_on("file_per_table");
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err=ib_startup("Antelope");
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
ib_trx_t trx;
ib_crsr_t crsr;
trx=ib_trx_begin(IB_TRX_REPEATABLE_READ);
assert(trx != NULL);
err=ib_cursor_open_table(dtname,trx,&crsr);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
ib_tpl_t tpl;
tpl=ib_clust_read_tuple_create(crsr);
assert(tpl != NULL);
err=ib_cursor_first(crsr);
while(err == DB_SUCCESS){
err=ib_cursor_read_row(crsr,tpl);
print_tuple(stdout,tpl);
err=ib_cursor_next(crsr);
tpl=ib_tuple_clear(tpl);
}
ib_tuple_delete(tpl);
err=ib_cursor_close(crsr);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err=ib_trx_commit(trx);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
err=ib_shutdown(IB_SHUTDOWN_NORMAL);
if(err != DB_SUCCESS){
puts(ib_strerror(err));
return err;
}
return 0;
}
int
main(int argc, char* argv[])
{
ib_tbl_sch_t ib_tbl_sch = NULL;
ib_id_t table_id;
int valid_page_sizes[] = {0, 1, 2, 4, 8, 16};
int invalid_page_sizes[] = {3, 5, 6, 14, 17, 32, 128, 301};
size_t i;
(void)argc;
(void)argv;
OK(ib_init());
test_configure();
OK(ib_startup("barracuda"));
OK(ib_cfg_set("file_per_table", IB_TRUE));
OK(ib_database_create(DBNAME));
for (i = 0;
i < sizeof(valid_page_sizes) / sizeof(valid_page_sizes[0]);
i++) {
ib_trx_t ib_trx;
OK(ib_table_schema_create(TABLENAME, &ib_tbl_sch,
IB_TBL_COMPRESSED,
valid_page_sizes[i]));
OK(ib_table_schema_add_col(ib_tbl_sch, "c1", IB_INT,
IB_COL_UNSIGNED, 0 /* ignored */,
sizeof(int)));
ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
OK(ib_schema_lock_exclusive(ib_trx));
OK(ib_table_create(ib_trx, ib_tbl_sch, &table_id));
OK(ib_trx_commit(ib_trx));
ib_table_schema_delete(ib_tbl_sch);
ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
OK(ib_schema_lock_exclusive(ib_trx));
OK(ib_table_drop(ib_trx, TABLENAME));
OK(ib_trx_commit(ib_trx));
}
for (i = 0;
i < sizeof(invalid_page_sizes) / sizeof(invalid_page_sizes[0]);
i++) {
ib_err_t ib_err;
ib_err = ib_table_schema_create(TABLENAME, &ib_tbl_sch,
IB_TBL_COMPRESSED,
invalid_page_sizes[i]);
if (ib_err == DB_SUCCESS) {
fprintf(stderr, "Creating a compressed table with "
"page size %d succeeded but should have "
"failed", invalid_page_sizes[i]);
exit(EXIT_FAILURE);
}
}
/* ignore errors as there may be tables left over from other tests */
OK(ib_database_drop(DBNAME));
OK(ib_shutdown(IB_SHUTDOWN_NORMAL));
return(EXIT_SUCCESS);
}
int main(int argc, char* argv[])
{
int i;
ib_err_t err;
ib_crsr_t crsr;
ib_trx_t ib_trx;
#ifdef __WIN__
srand((int) time(NULL));
#else
srandom(time(NULL));
#endif
err = ib_init();
assert(err == DB_SUCCESS);
test_configure();
#ifndef __WIN__
set_options(argc, argv);
#endif /* __WIN__ */
err = ib_startup("barracuda");
assert(err == DB_SUCCESS);
err = create_database(DATABASE);
assert(err == DB_SUCCESS);
for (i = 0; i < 10; ++i) {
int j;
printf("Create table\n");
err = create_table(DATABASE, TABLE);
assert(err == DB_SUCCESS);
for (j = 0; j < 10; ++j) {
ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
assert(ib_trx != NULL);
err = open_table(DATABASE, TABLE, ib_trx, &crsr);
assert(err == DB_SUCCESS);
err = ib_cursor_lock(crsr, IB_LOCK_IX);
assert(err == DB_SUCCESS);
insert_random_rows(crsr);
update_random_rows(crsr);
err = ib_cursor_close(crsr);
assert(err == DB_SUCCESS);
crsr = NULL;
err = ib_trx_commit(ib_trx);
assert(err == DB_SUCCESS);
}
printf("Drop table\n");
err = drop_table(DATABASE, TABLE);
assert(err == DB_SUCCESS);
}
err = ib_shutdown(IB_SHUTDOWN_NORMAL);
assert(err == DB_SUCCESS);
#ifdef UNIV_DEBUG_VALGRIND
VALGRIND_DO_LEAK_CHECK;
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char* argv[])
{
ib_err_t err;
ib_crsr_t crsr;
ib_trx_t ib_trx;
(void) argc;
(void) argv;
err = ib_init();
assert(err == DB_SUCCESS);
test_configure();
err = ib_startup("barracuda");
assert(err == DB_SUCCESS);
err = create_database(DATABASE);
assert(err == DB_SUCCESS);
err = create_table(DATABASE, TABLE);
assert(err == DB_SUCCESS);
ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
assert(ib_trx != NULL);
err = open_table(DATABASE, TABLE, ib_trx, &crsr);
assert(err == DB_SUCCESS);
err = ib_cursor_lock(crsr, IB_LOCK_IX);
assert(err == DB_SUCCESS);
err = insert_random_rows(crsr);
assert(err == DB_SUCCESS);
err = ib_cursor_close(crsr);
assert(err == DB_SUCCESS);
crsr = NULL;
err = ib_trx_commit(ib_trx);
assert(err == DB_SUCCESS);
err = create_sec_index_1(DATABASE, TABLE);
assert(err == DB_SUCCESS);
err = test_create_temp_index(DATABASE, TABLE, "c2");
err = open_sec_index_1(DATABASE, TABLE);
assert(err == DB_SUCCESS);
err = drop_table(DATABASE, TABLE);
assert(err == DB_SUCCESS);
err = ib_shutdown(IB_SHUTDOWN_NORMAL);
assert(err == DB_SUCCESS);
#ifdef UNIV_DEBUG_VALGRIND
VALGRIND_DO_LEAK_CHECK;
#endif
return(EXIT_SUCCESS);
}
int main(int argc, char* argv[])
{
ib_err_t err;
ib_crsr_t crsr;
ib_trx_t ib_trx;
(void)argc;
(void)argv;
err = ib_init();
assert(err == DB_SUCCESS);
test_configure();
err = ib_startup("barracuda");
assert(err == DB_SUCCESS);
err = create_database(DATABASE);
assert(err == DB_SUCCESS);
printf("Create table\n");
err = create_table(DATABASE, TABLE);
assert(err == DB_SUCCESS);
printf("Begin transaction\n");
ib_trx = ib_trx_begin(IB_TRX_REPEATABLE_READ);
assert(ib_trx != NULL);
printf("Open cursor\n");
err = open_table(DATABASE, TABLE, ib_trx, &crsr);
assert(err == DB_SUCCESS);
printf("Lock table in IX\n");
err = ib_cursor_lock(crsr, IB_LOCK_IX);
assert(err == DB_SUCCESS);
printf("Insert rows\n");
err = insert_rows(crsr);
assert(err == DB_SUCCESS);
printf("Query table\n");
err = do_query(crsr);
assert(err == DB_SUCCESS);
printf("Close cursor\n");
err = ib_cursor_close(crsr);
assert(err == DB_SUCCESS);
crsr = NULL;
printf("Commit transaction\n");
err = ib_trx_commit(ib_trx);
assert(err == DB_SUCCESS);
printf("Drop table\n");
err = drop_table(DATABASE, TABLE);
assert(err == DB_SUCCESS);
err = ib_shutdown(IB_SHUTDOWN_NORMAL);
assert(err == DB_SUCCESS);
#ifdef UNIV_DEBUG_VALGRIND
VALGRIND_DO_LEAK_CHECK;
#endif
return(EXIT_SUCCESS);
}
