예제 #1
0
void DbPlugin::getNextBar (QDateTime &startDate, Bar &bar)
{
  DBT key, data;
  DBC *cur;
  memset(&key, 0, sizeof(DBT));
  memset(&data, 0, sizeof(DBT));

  DBBar dbbar;
  memset(&dbbar, 0, sizeof(DBBar));
  data.data = &dbbar;
  data.ulen = sizeof(DBBar); 
  data.flags = DB_DBT_USERMEM;  

  db->cursor(db, NULL, &cur, 0);

  QString s = startDate.toString("yyyyMMddhhmmss");
  key.data = (char *) s.latin1();
  key.size = s.length() + 1;
  cur->c_get(cur, &key, &data, DB_SET_RANGE);
  int ret = cur->c_get(cur, &key, &data, DB_NEXT);
  if (ret)
  {
//    char *err = db_strerror(ret);
//    qDebug("%s %s", s.latin1(), err);
    cur->c_close(cur);
    return;
  }
  s = (char *) key.data;
  getBar(dbbar, s, bar);
  cur->c_close(cur);
}
예제 #2
0
/**
 * e_dbhash_foreach_key:
 * @edbh: an #EDbHash
 * @func: a callback function
 * @user_data: data to pass to @func
 *
 * Calls @func for each database object.
 **/
void
e_dbhash_foreach_key (EDbHash *edbh,
                      EDbHashFunc func,
                      gpointer user_data)
{
	DB *db;
	DBT dkey;
	DBT ddata;
	DBC *dbc;
	gint db_error = 0;

	g_return_if_fail (edbh != NULL);
	g_return_if_fail (edbh->priv != NULL);
	g_return_if_fail (func != NULL);

	db = edbh->priv->db;

	db_error = db->cursor (db, NULL, &dbc, 0);

	if (db_error != 0) {
		return;
	}

	memset (&dkey, 0, sizeof (DBT));
	memset (&ddata, 0, sizeof (DBT));
	db_error = dbc->c_get (dbc, &dkey, &ddata, DB_FIRST);

	while (db_error == 0) {
		(*func) ((const gchar *) dkey.data, user_data);

		db_error = dbc->c_get (dbc, &dkey, &ddata, DB_NEXT);
	}
	dbc->c_close (dbc);
}
예제 #3
0
int ftfs_bstore_scan_one_page(DB *data_db, struct ftfs_meta_key *meta_key,
                              DB_TXN *txn, struct page *page)
{
	int ret;
	uint64_t block_num;
	size_t block_offset;
	loff_t offset;
	size_t len;
	struct ftfs_data_key *data_key;
	void *buf, *value_buf;
	DBT key_dbt, value_dbt;
	DBC *cursor;

	offset = page_offset(page);
	block_num = block_get_num_by_position(offset);
	data_key = kmalloc(DATA_KEY_MAX_LEN, GFP_KERNEL);
	if (!data_key)
		return -ENOMEM;
	value_buf = kmalloc(FTFS_BSTORE_BLOCKSIZE, GFP_KERNEL);
	if (!value_buf) {
		ret = -ENOMEM;
		goto out1;
	}
	copy_data_key_from_meta_key(data_key, meta_key, block_num);
	dbt_init(&key_dbt, data_key, DATA_KEY_MAX_LEN);
	dbt_init(&value_dbt, value_buf, FTFS_BSTORE_BLOCKSIZE);
	len = PAGE_CACHE_SIZE;
	buf = kmap(page);
	ret = data_db->cursor(data_db, txn, &cursor, DB_CURSOR_FLAGS);
	if (ret)
		goto out2;
	ret = cursor->c_get(cursor, &key_dbt, &value_dbt, DB_SET_RANGE);
	while (len > 0 && ret) {
		ssize_t read_size;
		block_num = block_get_num_by_position(offset);
		block_offset = block_get_offset_by_position(offset);
		read_size = min(len, (FTFS_BSTORE_BLOCKSIZE - block_offset));

		if (data_key->circle_id == meta_key->circle_id &&
		    !strcmp(data_key->path, meta_key->path) &&
		    data_key->block_num == block_num) {
			memcpy(buf, value_buf, read_size);
			ret = cursor->c_get(cursor, &key_dbt, &value_dbt, DB_NEXT);
		} else
			memset(buf, 0, read_size);

		buf += read_size;
		offset += read_size;
		len -= read_size;
	}

	cursor->c_close(cursor);
out2:
	kunmap(page);
out1:
	kfree(value_buf);
	data_key_free(data_key);
	return ret;
}
예제 #4
0
파일: bdb.c 프로젝트: w796933/bind99damp
bdb_lookup(const char *zone, const char *name, void *dbdata,
	   dns_sdblookup_t *l)
#endif /* DNS_CLIENTINFO_VERSION */
{
	int ret;
	char *type, *rdata;
	dns_ttl_t ttl;
	isc_consttextregion_t ttltext;
	DBC *c;
	DBT key, data;

	UNUSED(zone);
#ifdef DNS_CLIENTINFO_VERSION
	UNUSED(methods);
	UNUSED(clientinfo);
#endif /* DNS_CLIENTINFO_VERSION */

	if ((ret = ((DB *)dbdata)->cursor((DB *)dbdata, NULL, &c, 0)) != 0) {
		isc_log_iwrite(dns_lctx, DNS_LOGCATEGORY_DATABASE,
			       DNS_LOGMODULE_SDB, ISC_LOG_ERROR,
			       isc_msgcat, ISC_MSGSET_GENERAL,
			       ISC_MSG_FAILED, "DB->cursor: %s",
			       db_strerror(ret));
		return ISC_R_FAILURE;
	}

	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));

	(const char *)key.data = name;
	key.size = strlen(name);

	ret = c->c_get(c, &key, &data, DB_SET);
	while (ret == 0) {
		((char *)key.data)[key.size] = 0;
		((char *)data.data)[data.size] = 0;
		ttltext.base = strtok((char *)data.data, " ");
		ttltext.length = strlen(ttltext.base);
		dns_ttl_fromtext((isc_textregion_t *)&ttltext, &ttl);
		type = strtok(NULL, " ");
		rdata = type + strlen(type) + 1;

		if (dns_sdb_putrr(l, type, ttl, rdata) != ISC_R_SUCCESS) {
			isc_log_iwrite(dns_lctx,
				       DNS_LOGCATEGORY_DATABASE,
				       DNS_LOGMODULE_SDB, ISC_LOG_ERROR,
				       isc_msgcat, ISC_MSGSET_GENERAL,
				       ISC_MSG_FAILED, "dns_sdb_putrr");
			return ISC_R_FAILURE;
		}
		ret = c->c_get(c, &key, &data, DB_NEXT_DUP);
	}

	c->c_close(c);
	return ISC_R_SUCCESS;
}
예제 #5
0
void DbPlugin::getHistory (BarData *barData, QDateTime &startDate)
{
  switch (type)
  {
    case Index1:
      getIndexHistory(barData, startDate);
      barData->createDateList();
      return;
      break;
    case Spread1:
      getSpreadHistory(barData, startDate);
      barData->createDateList();
      return;
      break;
    case CC1:
      getCCHistory(barData, startDate);
      barData->createDateList();
      return;
      break;
    default:
      break;
  }

  DBT key, data;
  DBC *cur;
  memset(&key, 0, sizeof(DBT));
  memset(&data, 0, sizeof(DBT));

  DBBar dbbar;
  memset(&dbbar, 0, sizeof(DBBar));
  data.data = &dbbar;
  data.ulen = sizeof(DBBar); 
  data.flags = DB_DBT_USERMEM;  

  db->cursor(db, NULL, &cur, 0);

  QString s = startDate.toString("yyyyMMddhhmmss");
  key.data = (char *) s.latin1();
  key.size = s.length() + 1;
  cur->c_get(cur, &key, &data, DB_SET_RANGE);

  while (! cur->c_get(cur, &key, &data, DB_PREV))
  {
    if (barData->count() >= barRange)
      break;
    Bar bar;
    s = (char *) key.data;
    getBar(dbbar, s, bar);
    bar.setTickFlag(barData->getBarType());
    barData->prepend(bar);
  }
  
  cur->c_close(cur);
  barData->createDateList();
}
예제 #6
0
/* Display all the stock quote information in the database. */
int
print_stocks(DB *dbp)
{
    DBC *dbc;
    DBT key, data;
#define	   MAXKEYSIZE    10
#define	   MAXDATASIZE    20
    char keybuf[MAXKEYSIZE + 1], databuf[MAXDATASIZE + 1];
    int ret, t_ret;
    u_int32_t keysize, datasize;

    if ((ret = dbp->cursor(dbp, NULL, &dbc, 0)) != 0) {
	dbp->err(dbp, ret, "can't open cursor");
	return (ret);
    }

    memset(&key, 0, sizeof(key));
    memset(&data, 0, sizeof(data));

    printf("\tSymbol\tPrice\n");
    printf("\t======\t=====\n");

    for (ret = dbc->c_get(dbc, &key, &data, DB_FIRST);
	ret == 0;
	ret = dbc->c_get(dbc, &key, &data, DB_NEXT)) {
	keysize = key.size > MAXKEYSIZE ? MAXKEYSIZE : key.size;
	memcpy(keybuf, key.data, keysize);
	keybuf[keysize] = '\0';

	datasize = data.size >= MAXDATASIZE ? MAXDATASIZE : data.size;
	memcpy(databuf, data.data, datasize);
	databuf[datasize] = '\0';

	printf("\t%s\t%s\n", keybuf, databuf);
    }
    printf("\n");
    fflush(stdout);

    if ((t_ret = dbc->c_close(dbc)) != 0 && ret == 0)
	ret = t_ret;

    switch (ret) {
    case 0:
    case DB_NOTFOUND:
	return (0);
    case DB_LOCK_DEADLOCK:
	return (0);
    default:
	return (ret);
    }
}
예제 #7
0
파일: store.c 프로젝트: briancline/accord
int store_list(const char *key, int (*add_file)(const char *, void *),
	       void *opaque, struct acrd_txid *txid)
{
	DBT db_key, db_data;
	int ret;
	DB_TXN *tid = NULL;
	DBC *cursor;

	if (txid)
		tid = txid->tid;

	ret = dbp->cursor(dbp, tid, &cursor, DB_DIRTY_READ);
	if (ret) {
		eprintf("failed open a cursor\n");
		return ACRD_ERR_UNKNOWN;
	}

	memset(&db_key, 0, sizeof(db_key));
	memset(&db_data, 0, sizeof(db_data));

	if (key) {
		db_key.data = (void *)key;
		db_key.size = strlen(key) + 1;

		ret = cursor->c_get(cursor, &db_key, &db_data, DB_SET_RANGE);
	} else
		ret = cursor->c_get(cursor, &db_key, &db_data, DB_FIRST);

	while (ret == 0) {
		if (key && strncmp(db_key.data, key, strlen(key)) != 0)
			/* prefix doesn't match */
			break;

		ret = add_file(db_key.data, opaque);
		if (ret != 0)
			break;

		ret = cursor->c_get(cursor, &db_key, &db_data, DB_NEXT);
	};

	if (ret == 0 || ret == DB_NOTFOUND)
		ret = ACRD_SUCCESS;
	else {
		envp->err(envp, ret, "store_list failed\n");
		ret = ACRD_ERR_UNKNOWN;
	}

	cursor->close(cursor);

	return ret;
}
예제 #8
0
/**
 * e_book_backend_db_cache_get_contacts:
 * @db: DB Handle
 * @query: an s-expression
 *
 * Returns a list of #EContact elements from @cache matching @query.
 * When done with the list, the caller must unref the contacts and
 * free the list.
 *
 * Returns: A #GList of pointers to #EContact.
 **/
GList *
e_book_backend_db_cache_get_contacts (DB *db,
                                      const gchar *query)
{
	DBC	*dbc;
	DBT	uid_dbt, vcard_dbt;
	gint	db_error;
	GList *list = NULL;
	EBookBackendSExp *sexp = NULL;
	EContact *contact;

	if (query) {
		sexp = e_book_backend_sexp_new (query);
		if (!sexp)
			return NULL;
	}

	db_error = db->cursor (db, NULL, &dbc, 0);
	if (db_error != 0) {
		g_warning ("db->cursor failed with %d", db_error);
		if (sexp)
			g_object_unref (sexp);
		return NULL;
	}

	memset (&vcard_dbt, 0 , sizeof (vcard_dbt));
	memset (&uid_dbt, 0, sizeof (uid_dbt));
	db_error = dbc->c_get (dbc, &uid_dbt, &vcard_dbt, DB_FIRST);

	while (db_error == 0) {
		if (vcard_dbt.data && !strncmp (vcard_dbt.data, "BEGIN:VCARD", 11)) {
			contact = e_contact_new_from_vcard (vcard_dbt.data);

			if (!sexp || e_book_backend_sexp_match_contact (sexp, contact))
				list = g_list_prepend (list, contact);
			else
				g_object_unref (contact);
		}
		db_error = dbc->c_get (dbc, &uid_dbt, &vcard_dbt, DB_NEXT);
	}

	db_error = dbc->c_close (dbc);
	if (db_error != 0)
		g_warning ("db->c_close failed with %d", db_error);

	if (sexp)
		g_object_unref (sexp);

	return g_list_reverse (list);
}
예제 #9
0
int dump_db()
{
     DBC *dbc;
     DBT db_key, db_data;
     int ret, i;
     void *store;
     void **store_index;

     printf("Going to dump database!\n");

     if(key_ops != &ci_str_ops ||val_ops != &ci_str_ops) {
	 ci_debug_printf(1, "can not dump not string databases\n");
	 return 0;
     }
     
     if ((ret = db->cursor(db, NULL, &dbc, 0)) != 0) {
	 ci_debug_printf(1, "error creating cursor\n");
	 return 0;
     }

     memset(&db_data, 0, sizeof(db_data));
     memset(&db_key, 0, sizeof(db_key));

     if ((ret = dbc->c_get(dbc, &db_key, &db_data, DB_SET_RANGE)) != 0){
	 ci_debug_printf(1, "error getting first element of DB : %s\n", db_strerror(ret));
	 dbc->c_close(dbc);
	 return 0;
     }

     do {
	 printf("%s :", (char *)db_key.data );
         if (db_data.data) {
	     store = db_data.data;
	     store_index = store;
	     for(i=0; store_index[i]!=0; i++) {
	          store_index[i]+=(long int)store;
	     }
	     for(i=0; store_index[i]!=0; i++) {
	         printf("%s |", (char *)store_index[i]);
	     }
          }
	  printf("\n");
       ret = dbc->c_get(dbc, &db_key, &db_data, DB_NEXT);
     } while (ret==0);

     dbc->c_close(dbc);
     return 1;
}
예제 #10
0
파일: ngram.cpp 프로젝트: twlkyao/libpinyin
bool Bigram::get_all_items(GArray * items){
    g_array_set_size(items, 0);

    if ( !m_db )
        return false;

    DBC * cursorp = NULL;
    DBT key, data;
    int ret;
    /* Get a cursor */
    m_db->cursor(m_db, NULL, &cursorp, 0); 

    /* Initialize our DBTs. */
    memset(&key, 0, sizeof(DBT));
    memset(&data, 0, sizeof(DBT));
        
    /* Iterate over the database, retrieving each record in turn. */
    while ((ret = cursorp->c_get(cursorp, &key, &data, DB_NEXT)) == 0) {
        assert(key.size == sizeof(phrase_token_t));
        phrase_token_t * token = (phrase_token_t *)key.data;
        g_array_append_val(items, *token);
    }

    assert (ret == DB_NOTFOUND);

    /* Cursors must be closed */
    if (cursorp != NULL) 
        cursorp->c_close(cursorp); 

    return true;
}
예제 #11
0
파일: db3.c 프로젝트: crossbuild/rpm
static int dbiCursorDel(dbiCursor dbc, DBT * key, DBT * data, unsigned int flags)
{
    int rc = EINVAL;
    int sane = (key->data != NULL && key->size > 0);

    if (dbc && sane) {
	DBC * cursor = dbc->cursor;
	int _printit;
	rpmdb rdb = dbc->dbi->dbi_rpmdb;
	rpmswEnter(&rdb->db_delops, 0);

	/* XXX TODO: insure that cursor is positioned with duplicates */
	rc = cursor->c_get(cursor, key, data, DB_SET);
	/* XXX DB_NOTFOUND can be returned */
	_printit = (rc == DB_NOTFOUND ? 0 : _debug);
	rc = cvtdberr(dbc->dbi, "dbcursor->c_get", rc, _printit);

	if (rc == 0) {
	    rc = cursor->c_del(cursor, flags);
	    rc = cvtdberr(dbc->dbi, "dbcursor->c_del", rc, _debug);
	}
	rpmswExit(&rdb->db_delops, data->size);
    }
    return rc;
}
예제 #12
0
/* Silently does nothing if the key/value isn't found.
   Can't use auto-commit here! */
int db_del_kv(DB *db, DB_TXN *tid, 
	      unsigned char *key, u_int32_t key_size,
	      unsigned char *value, u_int32_t value_size) {
  DBT DBTKey, DBTValue;
  DBC *cursor;
  int ret, c_ret;

  memset(&DBTKey, 0, sizeof(DBT));
  DBTKey.data = key;
  DBTKey.size = key_size;
  memset(&DBTValue, 0, sizeof(DBT));
  DBTValue.data = value;
  DBTValue.size = value_size;
  
  if ((ret = db->cursor(db, tid, &cursor, 0)) != 0)
    return ret;

  if ((ret = cursor->c_get(cursor, &DBTKey, &DBTValue, DB_GET_BOTH)) != 0)
    goto fail;

  ret = cursor->c_del(cursor, 0);

 fail:
  if ((c_ret = cursor->c_close(cursor)) != 0)
    return c_ret;
  return ret;
}
예제 #13
0
파일: db.c 프로젝트: smaclennan/samlib
int db_walk(void *dbh, int (*walk_func)(char *key, void *data, int len))
{
	DBT key, data;
	DBC *dbc;
	int rc = 0;
	GET_DB(dbh);

	if (!walk_func)
		return -EINVAL;

	if ((rc = db->cursor(db, NULL, &dbc, 0))) {
		db->close(db, 0);
		return rc;
	}

	memset(&key, 0, sizeof(key));
	memset(&data, 0, sizeof(data));

	while (dbc->c_get(dbc, &key, &data, DB_NEXT) == 0)
		if ((rc = walk_func(key.data, data.data, data.size)))
			break;

	dbc->c_close(dbc);

	return rc;
}
예제 #14
0
static void scanscan_hwc (void) {
    int r;
    int counter=0;
    for (counter=0; counter<n_experiments; counter++) {
        long long totalbytes=0;
        int rowcounter=0;
        double prevtime = gettime();
        DBT k,v;
        DBC *dbc;
        r = db->cursor(db, tid, &dbc, 0);                           assert(r==0);
        memset(&k, 0, sizeof(k));
        memset(&v, 0, sizeof(v));
        u_int32_t c_get_flags = DB_NEXT;
        if (prelockflag && (counter || prelock)) {
            c_get_flags |= lock_flag;
        }
        while (0 == (r = dbc->c_get(dbc, &k, &v, c_get_flags))) {
        
            //printf("r=%d\n", r);

            totalbytes += k.size + v.size;
            rowcounter++;
            if (limitcount>0 && rowcounter>=limitcount) break;
        }
        assert(r==DB_NOTFOUND);
        r = dbc->c_close(dbc);                                      assert(r==0);
        double thistime = gettime();
        double tdiff = thistime-prevtime;
        printf("Scan    %lld bytes (%d rows) in %9.6fs at %9fMB/s\n", totalbytes, rowcounter, tdiff, 1e-6*totalbytes/tdiff);
    }
}
예제 #15
0
파일: koef.c 프로젝트: arunanj/mrts-ng
int show_koef_db(DB *dbp)
{
	DBT key, data;
	DBC *cursorp;
	struct kdb_key	*kdbkeyp;
	struct kdb_data	*kdbdatap;
	int ret;

	dbp->cursor(dbp, NULL, &cursorp, 0); 
	/* Initialize our DBTs. */
	memset(&key, 0, sizeof(DBT));
	memset(&data, 0, sizeof(DBT));

	while ((ret = cursorp->c_get(cursorp, &key, &data, DB_NEXT)) == 0) {
		kdbkeyp  = (struct kdb_key *)  key.data;
		kdbdatap = (struct kdb_data *) data.data;
		fprintf(stdout,"%i : %x : %f\t%f\n",
			kdbkeyp->asdu,
			kdbkeyp->ioa2,
			kdbdatap->koef_u,
			kdbdatap->koef_i
		);
	}
	return 0;
}
예제 #16
0
파일: pctldb.c 프로젝트: noaaport/nbsp
static int pctlmfdb_stat(struct pctldb_st *pctldb, int *dberror){

  int status = 0;
  DB* mfdbp = pctldb->mfdbp;
  DBC *cursor;
  DBT key, data;
  uint32_t memfile_size;

  *dberror = mfdbp->cursor(mfdbp, NULL, &cursor, 0);
  if(*dberror != 0)
    return(-1);

  memset(&key, 0, sizeof(DBT));
  memset(&data, 0, sizeof(DBT));

  pctldb->mf_total_size = 0;
  while(status == 0){
    status = cursor->c_get(cursor, &key, &data, DB_NEXT);
    if(status == 0){
      memfile_size = data.size;
      pctldb->mf_total_size += memfile_size;
    }
  }

  cursor->c_close(cursor);

  if(status == DB_NOTFOUND)
    status = 0;
  else{
    *dberror = status;
    status = -1;
  }

  return(status);
}
예제 #17
0
int userToSubname_deletecol(struct userToSubnameDbFormat *userToSubnameDb,char subname[]) {
	DBC *cursorp;
	DBT key, data;
	int ret;

	debug("userToSubname_deletecol: deleting \"%s\"", subname);

	/* Get a cursor */
	(*userToSubnameDb).dbp->cursor((*userToSubnameDb).dbp, NULL, &cursorp, 0);

	//resetter minne
        memset(&key, 0, sizeof(DBT));
        memset(&data, 0, sizeof(DBT));

	/* Iterate over the database, retrieving each record in turn. */
	while ((ret = cursorp->c_get(cursorp, &key, &data, DB_NEXT)) == 0) {
    	    /* Do interesting things with the DBTs here. */
	    if (!strcmp(subname, data.data))
		{
		    debug("Deleting %s->%s (ret=%i)", (char*)key.data, (char*)data.data, cursorp->c_del(cursorp, 0));
		}
	    else
		{
		    debug("Keeping %s->%s", (char*)key.data, (char*)data.data);
		}
	}

	/* Close the cursor */
	if (cursorp != NULL) {
		cursorp->c_close(cursorp);
	}

	return 1;

}
예제 #18
0
파일: auth.c 프로젝트: Jc2k/exact
void auth_db_clean(int sig) {
    DBC *dbc;
    DBT key, data;
    int ret;
    time_t now=time(NULL);
    time_t max=(time_t)conffile_param_int("timeout");

    logger(LOG_NOTICE, "cleaning db file\n");
    // apparently i should use DB_WRITECURSOR as a flag here
    // but the version 3 db barfs on me when i do that
    if((ret = db->cursor(db, NULL, &dbc, 0)) != 0) {
        db->err(db, ret, "opening cursor");
        exit(22);
    }
    memset(&key, 0, sizeof(key));
    memset(&data, 0, sizeof(data));
    while((ret = dbc->c_get(dbc, &key, &data, DB_NEXT)) ==0) {
        time_t then = (time_t)data.data;
        if(now - then > max) {
            if((ret = dbc->c_del(dbc, 0)) != 0) {
                db->err(db, ret, "deleting key");
                exit(22);
            }
        }
    }
    logger(LOG_DEBUG,"Finished cleaning cycle\n");
}
예제 #19
0
파일: auth.c 프로젝트: Jc2k/exact
void auth_db_dump() {
    DBC *dbc;
    DBT key, data;
    int ret;
    FILE *f=fopen(conffile_param("dumpfile"),"w");

    if(!f) {
        logger(LOG_ERR, "Unable to write to dump file %s\n", conffile_param("dumpfile"));
        return;
    }
    chmod(conffile_param("dumpfile"),0640);
    logger(LOG_NOTICE, "dumping state\n");

    if((ret = db->cursor(db, NULL, &dbc, 0)) != 0) {
        db->err(db, ret, "opening cursor");
        exit(22);
    }
    memset(&key, 0, sizeof(key));
    memset(&data, 0, sizeof(data));
    while((ret = dbc->c_get(dbc, &key, &data, DB_NEXT)) ==0) {
        char tbuff[1024];
        char *hostname=key.data;
        time_t *time=data.data;
        strftime(tbuff, 1023, "%Y-%m-%d %H:%M:%S", localtime(time));
        fprintf(f, "%s\t%s\n", hostname, tbuff);
    }
    fclose(f);
}
예제 #20
0
파일: data.c 프로젝트: Tayyib/uludag
int
db_get_instances(int node_no, const char *app, const char *key, void (*func)(char *str, size_t size))
{
	struct databases db;
	DBC *cursor = NULL;
	DBT pair[2];
	int e, ret = -1;
	char *match;

	memset(&pair[0], 0, sizeof(DBT) * 2);

	if (open_env(&db, PROFILE_DB)) goto out;
	blaa = &db;

	db.profile->cursor(db.profile, NULL, &cursor, 0);

	// FIXME: multiple instance keys?
	match = make_profile_key(node_no, app, key, NULL);
	if (!match) goto out;
	while ((e = cursor->c_get(cursor, &pair[0], &pair[1], DB_NEXT)) == 0) {
		if (strncmp(match, pair[0].data, strlen(match)) == 0)
			func(((char *) pair[0].data) + strlen(match), pair[0].size - strlen(match));
	}
	if (e != DB_NOTFOUND) {
		goto out;
	}

	ret = 0;
out:
	blaa = NULL;
	if (cursor) cursor->c_close(cursor);
	close_env(&db);
	return ret;
}
예제 #21
0
int
scan_db(DB *dbp)
{
    DBC *cursor;
    int ret, num_recs = 0;
    DBT key, data;

    ret = dbp->cursor(dbp, 0, &cursor, 0);
    if(ret)
    {
	db_error("DB->cursor", ret);
	return ret;
    }

    memset(&key, 0, sizeof(DBT));    
    memset(&data, 0, sizeof(DBT));
    
    while( (ret = cursor->c_get(cursor, &key, &data, DB_NEXT)) == 0)
	num_recs++;
    
    if(ret == DB_NOTFOUND)
	printf("Scan of %s completed successfully. Scanned %d records\n",
	       dbp->fname, num_recs);
    else
    {
	db_error("DBC->get", ret);
	return ret;
    }
    cursor->c_close(cursor);
    return 0;
}
예제 #22
0
void DbPlugin::getAllBars (BarData *bars)
{
  DBT key, data;
  DBC *cur;
  memset(&key, 0, sizeof(DBT));
  memset(&data, 0, sizeof(DBT));

  DBBar dbbar;
  memset(&dbbar, 0, sizeof(DBBar));
  data.data = &dbbar;
  data.ulen = sizeof(DBBar); 
  data.flags = DB_DBT_USERMEM;  

  db->cursor(db, NULL, &cur, 0);

  while (! cur->c_get(cur, &key, &data, DB_PREV))
  {
    Bar bar;
    QString s = (char *) key.data;
    getBar(dbbar, s, bar);
    bar.setTickFlag(bars->getBarType());
    bars->prependRaw(bar);
  }

  cur->c_close(cur);
}
예제 #23
0
파일: db3.c 프로젝트: crossbuild/rpm
static int dbiCursorGet(dbiCursor dbc, DBT * key, DBT * data, unsigned int flags)
{
    int rc = EINVAL;
    int sane = ((flags == DB_NEXT) || (key->data != NULL && key->size > 0));

    if (dbc && sane) {
	DBC * cursor = dbc->cursor;
	rpmdb rdb = dbc->dbi->dbi_rpmdb;
	int _printit;
	rpmswEnter(&rdb->db_getops, 0);

	/* XXX db4 does DB_FIRST on uninitialized cursor */
	rc = cursor->c_get(cursor, key, data, flags);
	/* XXX DB_NOTFOUND can be returned */
	_printit = (rc == DB_NOTFOUND ? 0 : _debug);
	rc = cvtdberr(dbc->dbi, "dbcursor->c_get", rc, _printit);

	/* Remember the last key fetched */
	if (rc == 0) {
	    dbc->key = key->data;
	    dbc->keylen = key->size;
	} else {
	    dbc->key = NULL;
	    dbc->keylen = 0;
	}

	rpmswExit(&rdb->db_getops, data->size);
    }
    return rc;
}
예제 #24
0
void ReadFromDBAndPutInFile(FILE *outFile)
{
  pwr_tInt32 ret, sts;
  pwr_tUInt32 nrOfEvents = 0;
  sEvent *eventp;
  DBT data, key;
  DBC *dbcp;
  
  WriteColumnNames(outFile);
  
  /* Acquire a cursor for the database. */ 
  if ((ret = dataBaseP->cursor(dataBaseP, NULL, &dbcp, 0)) != 0) 
  {
    printf("error dataBaseP->cursor: %s\n", db_strerror(ret)); 
    exit(1);
  }

  /* Initialize the key/data return pair. */
  memset(&key, 0, sizeof(key));
  memset(&data, 0, sizeof(data));
  
  if((ret = dbcp->c_get(dbcp, &key, &data, DB_FIRST)) == 0)
  {
    eventp = data.data;
    sts = Write(eventp, outFile);
    nrOfEvents++;
  }
  
  while((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0)
  {
    eventp = data.data;
    sts = Write(eventp, outFile);
    nrOfEvents++;
  }
  if(ret != DB_NOTFOUND)
  {
    printf("error dbcp->c_get: %s\n", db_strerror(ret));
    printf("** Error reading post number %u, terminating\n", nrOfEvents);
    exit(1);
  }
  printf("-- Number of events written to file: %u\n", nrOfEvents);
  /*Close the cursor*/
  if((ret = dbcp->c_close(dbcp)) != 0)
  {
    printf("Error dbcp->c_close(): %s\n", db_strerror(ret));
  }       
}  
예제 #25
0
/* estimate average component length for components (approx) */
double 
se_get_avg_component_len(component_list_entry *comp)
{
  DBT key, data;
  DBC *dbcursor;
  component_data_item comp_data;
  int comp_id;
  int n, numrecs;
  int errno;
  double sum_size, avg_size;
  
  /* the component database should already be opened before this */
  /* function is called                                          */

  if (comp == NULL || comp->comp_db == NULL) 
    return (0.0); /* no data */

  
  /* Acquire a cursor for the database. */
  if ((errno = comp->comp_db->cursor(comp->comp_db, 
				     NULL, &dbcursor, 0)) != 0) {
    fprintf(stderr, "se_get_avg_component_len: cursor open error: %s\n", strerror(errno));
    return(0.0);
  }

  /* Initialize the key/data pair so the flags aren't set. */
  memset(&key, 0, sizeof(key));
  memset(&data, 0, sizeof(data));
  
  /* Walk through the database and get the start and end info for comp */
  numrecs = 100;
  n = 0;

  while ((errno = dbcursor->c_get(dbcursor, &key, &data, DB_NEXT)) == 0
	 || numrecs > 0) {
    
    numrecs--;
    n++;

    if (key.size == sizeof(int)) {
      memcpy((char *)&comp_data,data.data,data.size);
      sum_size += (double)(comp_data.end_offset - comp_data.start_offset);
    }
    
  }

  (void)dbcursor->c_close(dbcursor);
  
  if (n > 0) {
    avg_size = sum_size/(double)n;
    
  }
  
  return(avg_size);

}
예제 #26
0
static void
run_expiry()
{
    DBC *dbcp;
    int rc;
    time_t now;
    unsigned int count = 0;
    /* Cursor operations can hold several locks and therefore deadlock
       so don't run expiry if deadlock detection does not work
       http://www.oracle.com/technology/documentation/berkeley-db/db/ref/lock/notxn.html */
    if (db == 0 || deadlock_detect == 0)
        return;
    if (time(&now) == (time_t)-1) {
        syslog(LOG_ERR, "time failed during run_expiry");
        return;
    }
    muffle_error++;
    if (rc = db->cursor(db, 0, &dbcp, 0))
        log_db_error("db->cursor failed during expiry run", rc);
    else {
        DBT key = { 0 };
        while ((rc = dbcp->c_get(dbcp, &key, &dbdata, DB_NEXT | DB_RMW)) == 0) {
            time_t ref_time;
            double age_max, age;
            if (triplet_data.pass_count) {
                ref_time = triplet_data.access_time;
                age_max = pass_max_idle;
            }
            else {
                ref_time = triplet_data.create_time;
                age_max = bloc_max_idle;
            }
            age = difftime(now, ref_time);
            if (age > age_max) {
                if (opt_verbose)
                    syslog(LOG_INFO, "Expiring %s %s after %.0f seconds idle",
                           key.data,
                           triplet_data.pass_count ? "pass" : "block", age);
                if (rc = dbcp->c_del(dbcp, 0))
                    log_db_error("dbcp->c_del failed", rc);
                else
                    count++;
            }
        }
        if (rc == DB_LOCK_DEADLOCK)
            syslog(LOG_DEBUG, "skipping concurrent expiry avoids "
                   "deadlocks and unnecessary work");
        else if (rc != DB_NOTFOUND)
            log_db_error("dbcp->c_get failed", rc);
        if (rc = dbcp->c_close(dbcp))
            log_db_error("dbcp->c_close failed", rc);
    }
    muffle_error--;
    if (count)
        syslog(LOG_NOTICE, "Expired %u triplets", count);
}
예제 #27
0
파일: dn2id.c 프로젝트: cptaffe/openldap
int
hdb_dn2id_parent(
	Operation *op,
	DB_TXN *txn,
	EntryInfo *ei,
	ID *idp )
{
	struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
	DB *db = bdb->bi_dn2id->bdi_db;
	DBT		key, data;
	DBC	*cursor;
	int		rc = 0;
	diskNode *d;
	char	*ptr;
	ID	nid;

	DBTzero(&key);
	key.size = sizeof(ID);
	key.data = &nid;
	key.ulen = sizeof(ID);
	key.flags = DB_DBT_USERMEM;
	BDB_ID2DISK( ei->bei_id, &nid );

	DBTzero(&data);
	data.flags = DB_DBT_USERMEM;

	rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
	if ( rc ) return rc;

	data.ulen = sizeof(diskNode) + (SLAP_LDAPDN_MAXLEN * 2);
	d = op->o_tmpalloc( data.ulen, op->o_tmpmemctx );
	data.data = d;

	rc = cursor->c_get( cursor, &key, &data, DB_SET );
	if ( rc == 0 ) {
		if (d->nrdnlen[0] & 0x80) {
			rc = LDAP_OTHER;
		} else {
			db_recno_t dkids;
			ptr = (char *) data.data + data.size - sizeof(ID);
			BDB_DISK2ID( ptr, idp );
			ei->bei_nrdn.bv_len = (d->nrdnlen[0] << 8) | d->nrdnlen[1];
			ber_str2bv( d->nrdn, ei->bei_nrdn.bv_len, 1, &ei->bei_nrdn );
			ei->bei_rdn.bv_len = data.size - sizeof(diskNode) -
				ei->bei_nrdn.bv_len;
			ptr = d->nrdn + ei->bei_nrdn.bv_len + 1;
			ber_str2bv( ptr, ei->bei_rdn.bv_len, 1, &ei->bei_rdn );
			/* How many children does this node have? */
			cursor->c_count( cursor, &dkids, 0 );
			ei->bei_dkids = dkids;
		}
	}
	cursor->c_close( cursor );
	op->o_tmpfree( d, op->o_tmpmemctx );
	return rc;
}
예제 #28
0
bool Bigram::load_db(const char * dbfile){
    reset();

    /* create in memory db. */
    int ret = db_create(&m_db, NULL, 0);
    assert(ret == 0);

    ret = m_db->open(m_db, NULL, NULL, NULL,
                     DB_HASH, DB_CREATE, 0600);
    if ( ret != 0 )
        return false;

    /* load db into memory. */
    DB * tmp_db = NULL;
    ret = db_create(&tmp_db, NULL, 0);
    assert(ret == 0);

    if (NULL == tmp_db)
        return false;

    ret = tmp_db->open(tmp_db, NULL, dbfile, NULL,
                       DB_HASH, DB_RDONLY, 0600);
    if ( ret != 0 )
        return false;

    DBC * cursorp = NULL;
    DBT key, data;

    /* Get a cursor */
    tmp_db->cursor(tmp_db, NULL, &cursorp, 0);

    if (NULL == cursorp)
        return false;

    /* Initialize our DBTs. */
    memset(&key, 0, sizeof(DBT));
    memset(&data, 0, sizeof(DBT));

    /* Iterate over the database, retrieving each record in turn. */
    while ((ret = cursorp->c_get(cursorp, &key, &data, DB_NEXT)) == 0) {
        int ret = m_db->put(m_db, NULL, &key, &data, 0);
        assert(ret == 0);
    }
    assert (ret == DB_NOTFOUND);

    /* Cursors must be closed */
    if ( cursorp != NULL )
        cursorp->c_close(cursorp);

    if ( tmp_db != NULL )
        tmp_db->close(tmp_db, 0);

    return true;
}
예제 #29
0
static void scanscan_range (void) {
    int r;

    double texperiments[n_experiments];
    u_int64_t k = 0;
    char kv[8];
    DBT key, val;
  
    int counter;
    for (counter = 0; counter < n_experiments; counter++) {

        if (1) { //if ((counter&1) == 0) {   
        makekey:
            // generate a random key in the key range
            k = (start_range + (random() % (end_range - start_range))) * (1<<6);
            int i;
            for (i = 0; i < 8; i++)
                kv[i] = k >> (56-8*i);
        }
        memset(&key, 0, sizeof key); key.data = &kv, key.size = sizeof kv;
        memset(&val, 0, sizeof val);

        double tstart = gettime();

        DBC *dbc;
        r = db->cursor(db, tid, &dbc, 0); assert(r==0);

        // set the cursor to the random key
        r = dbc->c_get(dbc, &key, &val, DB_SET_RANGE+lock_flag);
        if (r != 0) {
            assert(r == DB_NOTFOUND);
            printf("%s:%d %" PRIu64 "\n", __FUNCTION__, __LINE__, k);
            goto makekey;
        }

#ifdef TOKUDB
        // do the range scan
        long rowcounter = 0;
        struct extra_count e = {0,0};
        while (limitcount > 0 && rowcounter < limitcount) {
            r = dbc->c_getf_next(dbc, prelockflag ? lock_flag : 0, counttotalbytes, &e);
            if (r != 0)
                break;
            rowcounter++;
        }
#endif

        r = dbc->c_close(dbc);                                      
        assert(r==0);

        texperiments[counter] = gettime() - tstart;
        printf("%" PRIu64 " %f\n", k, texperiments[counter]); fflush(stdout);
    }
예제 #30
0
/* FIXME should this be wrapped in an explicit transaction? */
static void
do_dump_triplets()
{
    DB *db;
    DBC *dbcp;
    int rc;
    DBT key = { 0 },
	data = { 0 };
    rc = get_db(&db, 1);
    if (rc) {
	fprintf(stderr, "DBD-%d: failed to open database\n", rc);
	return;
    }
    rc = db->cursor(db, 0, &dbcp, 0);
    if (rc)
	fprintf(stderr, "DBD-%d: db->cursor failed: %s\n",
		rc, db_strerror(rc));
    else {
	while (! exit_requested
	       && (rc = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) {
	    const char *const start = key.data, *s = start;
	    const struct triplet_data *t = data.data;
	    printf("%d\t", t->crypted);
	    printf("%s\t", db_key_ntop(s));
	    switch ((enum dbkey_type_enum)*s++) {
	    case DBKEY_T_RAW:
		s += strlen(s) + 1;
		break;
	    case DBKEY_T_IP4:
		s += IPV4_BITS / 8;
		break;
	    case DBKEY_T_IP6:
		s += IPV6_BITS / 8;
		break;
	    }
	    printf("%s\t", s);
	    s += strlen(s) + 1;
	    fwrite(s, 1, key.size - (s - start), stdout);
	    putchar('\t');
	    write_ctime(&t->create_time);
	    putchar('\t');
	    write_ctime(&t->access_time);
	    printf("\t%lu\t%lu\n", t->block_count, t->pass_count);
	}
	if (rc && rc != DB_NOTFOUND)
	    fprintf(stderr, "DBD-%d: dbcp->c_get failed: %s\n",
		    rc, db_strerror(rc));
	rc = dbcp->c_close(dbcp);
	if (rc)
	    fprintf(stderr, "DBD-%d: dbcp->c_close failed: %s\n",
		    rc, db_strerror(rc));
    }
}