void* BasicHashTable::Lookup(char const* key) const {
unsigned index;
TableEntry* entry = lookupKey(key, index);
if (entry == NULL) return NULL; // no such entry
return entry->value;
}
valObject *execGetCommand(char (*argv)[ARGUMENTCNT]) {
int dbindex = -1;
valObject *val;
dbindex = chrtoint(argv[1])%(THREADCNT);
val = lookupKey(db[dbindex], argv[1]);
return val;
}
const T& at(size_t idx) const
{
auto iter = lookupKey(idx);
if(iter == mIdxLookup.cend())
throw std::out_of_range("SparseArray::at: index "+std::to_string(idx)+" does not exist");
return mData[std::distance(mIdxLookup.cbegin(), iter)];
}
const_iterator find(size_t idx) const
{
auto iter = lookupKey(idx);
if(iter == mIdxLookup.cend())
mData.cend();
return mData.cbegin() + std::distance(mIdxLookup.cbegin(), iter);
}
IndexEntry const * lookupKeyPointer(uint64_t const k) const
{
uint64_t const i = lookupKey(k);
if ( i+1 < index.size() )
return &(index[i]);
else
return 0;
}
void RemoteExpress::onpress(unsigned long code, void (*cb) (unsigned long code)){
int i = lookupKey(code);
if (i < 0){
i = addLookupKey(code);
}
lookupCB[i] = cb;
}
Boolean BasicHashTable::Remove(char const* key) {
unsigned index;
TableEntry* entry = lookupKey(key, index);
if (entry == NULL) return False; // no such entry
deleteEntry(index, entry);
return True;
}
void erase(size_t idx)
{
auto iter = lookupKey(idx);
if(iter == mIdxLookup.cend())
return;
mData.erase(std::next(mData.cbegin(), std::distance(mIdxLookup.cbegin(), iter)));
mIdxLookup.erase(iter);
}
void RemoteExpress::onhold(unsigned long code, unsigned long everyMicro, void (*cb) (unsigned long code, unsigned long microsSincePress)){
int i = lookupKey(code);
if (i < 0){
i = addLookupKey(code);
}
lookupHoldEveryMicros[i] = everyMicro;
lookupHoldCB[i] = cb;
}
value_t *lookupKeyRead(memoryDb *db, sds *key) {
value_t *val;
expireIfNeeded(db, key);
val = lookupKey(db, key);
if (val == NULL)
stats.keyspace_misses++;
else
stats.keyspace_hits++;
return val;
}
robj *lookupKeyRead(redisDb *db, robj *key) {
robj *val;
expireIfNeeded(db,key);
val = lookupKey(db,key);
if (val == NULL)
server.stat_keyspace_misses++;
else
server.stat_keyspace_hits++;
return val;
}
// Look up the object for the given index. If an object at the given index
// doesn't exist, it will be allocated.
T& operator[](size_t idx)
{
auto iter = lookupKey(idx);
if(iter == mIdxLookup.cend())
{
iter = insertKey(idx).first;
idx = std::distance(mIdxLookup.cbegin(), iter);
return *mData.insert(mData.begin()+idx, T());
}
return mData[std::distance(mIdxLookup.cbegin(), iter)];
}
QSqlError pki_x509super::insertSqlData()
{
QSqlError e = lookupKey();
if (e.isValid())
return e;
XSqlQuery q;
SQL_PREPARE(q, "INSERT INTO x509super (item, subj_hash, pkey, key_hash) "
"VALUES (?, ?, ?, ?)");
q.bindValue(0, sqlItemId);
q.bindValue(1, (uint)getSubject().hashNum());
q.bindValue(2, privkey ? privkey->getSqlItemId() : QVariant());
q.bindValue(3, pubHash());
q.exec();
return q.lastError();
}
void* BasicHashTable::Add(char const* key, void* value) {
void* oldValue;
unsigned index;
TableEntry* entry = lookupKey(key, index);
if (entry != NULL) {
// There's already an item with this key
oldValue = entry->value;
} else {
// There's no existing entry; create a new one:
entry = insertNewEntry(index, key);
oldValue = NULL;
}
entry->value = value;
// If the table has become too large, rebuild it with more buckets:
if (fNumEntries >= fRebuildSize) rebuild();
return oldValue;
}
int RemoteExpress::handlePress(unsigned long value){
lastPressNumkey = -1;
lastPressIndex = -1;
int numkey = lookupNumkey(value);
if (numkey < 0){
int cbIndex = lookupKey(value);
if (cbIndex < 0)
return 0;
lastPressIndex = cbIndex;
holdEveryMicros = lookupHoldEveryMicros[cbIndex];
nextHoldTime = lastCodeTime + holdEveryMicros;
(*lookupCB[cbIndex])(value);
return 1;
}
else{
lastPressNumkey = numkey;
holdEveryMicros = numkeyHoldEveryMicros;
nextHoldTime = lastCodeTime + holdEveryMicros;
(* numkeyCB)(numkey);
return 1;
}
}
robj *lookupKeyRead(redisDb *db, robj *key) {
robj *val;
if (expireIfNeeded(db,key) == 1) {
/* Key expired. If we are in the context of a master, expireIfNeeded()
* returns 0 only when the key does not exist at all, so it's save
* to return NULL ASAP. */
if (server.masterhost == NULL) return NULL;
/* However if we are in the context of a slave, expireIfNeeded() will
* not really try to expire the key, it only returns information
* about the "logical" status of the key: key expiring is up to the
* master in order to have a consistent view of master's data set.
*
* However, if the command caller is not the master, and as additional
* safety measure, the command invoked is a read-only command, we can
* safely return NULL here, and provide a more consistent behavior
* to clients accessign expired values in a read-only fashion, that
* will say the key as non exisitng.
*
* Notably this covers GETs when slaves are used to scale reads. */
if (server.current_client &&
server.current_client != server.master &&
server.current_client->cmd &&
server.current_client->cmd->flags & CMD_READONLY)
{
return NULL;
}
}
val = lookupKey(db,key);
if (val == NULL)
server.stat_keyspace_misses++;
else
server.stat_keyspace_hits++;
return val;
}
bool Wizard::IniSettings::writeFile(const QString &path, QTextStream &stream)
{
// Look for a square bracket, "'\\["
// that has one or more "not nothing" in it, "([^]]+)"
// and is closed with a square bracket, "\\]"
QRegExp sectionRe(QLatin1String("^\\[([^]]+)\\]"));
// Find any character(s) that is/are not equal sign(s), "[^=]+"
// followed by an optional whitespace, an equal sign, and another optional whitespace, "\\s*=\\s*"
// and one or more periods, "(.+)"
QRegExp keyRe(QLatin1String("^([^=]+)\\s*=\\s*(.+)$"));
const QStringList keys(mSettings.keys());
QString currentSection;
QString buffer;
while (!stream.atEnd()) {
const QString line(stream.readLine());
if (line.isEmpty() || line.startsWith(QLatin1Char(';'))) {
buffer.append(line + QLatin1String("\n"));
continue;
}
if (sectionRe.exactMatch(line)) {
buffer.append(line + QLatin1String("\n"));
currentSection = sectionRe.cap(1);
} else if (keyRe.indexIn(line) != -1) {
QString key(keyRe.cap(1).trimmed());
QString lookupKey(key);
// Append the section, but only if there is one
if (!currentSection.isEmpty())
lookupKey = currentSection + QLatin1Char('/') + key;
buffer.append(key + QLatin1Char('=') + mSettings[lookupKey].toString() + QLatin1String("\n"));
mSettings.remove(lookupKey);
}
}
// Add the new settings to the buffer
QHashIterator<QString, QVariant> i(mSettings);
while (i.hasNext()) {
i.next();
QStringList fullKey(i.key().split(QLatin1Char('/')));
QString section(fullKey.at(0));
section.prepend(QLatin1Char('['));
section.append(QLatin1Char(']'));
QString key(fullKey.at(1));
int index = buffer.lastIndexOf(section);
if (index != -1) {
// Look for the next section
index = buffer.indexOf(QLatin1Char('['), index + 1);
if (index == -1 ) {
// We are at the last section, append it to the bottom of the file
buffer.append(QString("\n%1=%2").arg(key, i.value().toString()));
mSettings.remove(i.key());
continue;
} else {
// Not at last section, add the key at the index
buffer.insert(index - 1, QString("\n%1=%2").arg(key, i.value().toString()));
mSettings.remove(i.key());
}
} else {
// Add the section to the end of the file, because it's not found
buffer.append(QString("\n%1\n").arg(section));
i.previous();
}
}
// Now we reopen the file, this time we write
QFile file(path);
if (file.open(QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text)) {
QTextStream in(&file);
in.setCodec(stream.codec());
// Write the updated buffer to an empty file
in << buffer;
file.flush();
file.close();
} else {
return false;
}
return true;
}
void joinGeneric(redisClient *c,
jb_t *jb) {
if (jb->w.nob > 1) {
addReply(c, shared.join_m_obc);
return;
}
Order_by = jb->w.nob;
Order_by_col_val = NULL;
/* sort queried-columns to queried-indices */
jqo_t o_csort_order[MAX_COLUMN_PER_TABLE];
jqo_t csort_order [MAX_COLUMN_PER_TABLE];
for (int i = 0; i < jb->qcols; i++) {
for (int j = 0; j < jb->n_ind; j++) {
if (jb->j_tbls[i] == Index[server.dbid][jb->j_indxs[j]].table) {
csort_order[i].t = jb->j_tbls[i];
csort_order[i].i = j;
csort_order[i].c = jb->j_cols[i];
csort_order[i].n = i;
}
}
}
memcpy(&o_csort_order, &csort_order, sizeof(jqo_t) * jb->qcols);
qsort(&csort_order, jb->qcols, sizeof(jqo_t), cmp_jqo);
/* reorder queried-columns to queried-indices, will sort @ output time */
bool reordered = 0;
for (int i = 0; i < jb->qcols; i++) {
if (jb->j_tbls[i] != csort_order[i].t ||
jb->j_cols[i] != csort_order[i].c) {
reordered = 1;
jb->j_tbls[i] = csort_order[i].t;
jb->j_cols[i] = csort_order[i].c;
}
}
cswc_t *w = &jb->w; /* makes coding more compact */
w->tmatch = w->obt[0]; /* HACK: initOBsort needs w->tmatch */
list *ll = initOBsort(Order_by, w);
uchar pk1type = Tbl[server.dbid]
[Index[server.dbid][jb->j_indxs[0]].table].col_type[0];
bt *jbtr = createJoinResultSet(pk1type);
robj *rset[MAX_JOIN_INDXS];
for (int i = 1; i < jb->n_ind; i++) {
rset[i] = createValSetObject();
}
int j_ind_len [MAX_JOIN_INDXS];
int jind_ncols[MAX_JOIN_INDXS];
join_add_cols_t jc; /* these dont change in the loop below */
jc.qcols = jb->qcols;
jc.j_tbls = jb->j_tbls;
jc.j_cols = jb->j_cols;
jc.jind_ncols = jind_ncols;
jc.j_ind_len = j_ind_len;
jc.jbtr = jbtr;
for (int i = 0; i < jb->n_ind; i++) { /* iterate join indices */
btEntry *be, *nbe;
j_ind_len[i] = 0;
jc.index = i;
jc.itable = Index[server.dbid][jb->j_indxs[i]].table;
robj *btt = lookupKeyRead(c->db, Tbl[server.dbid][jc.itable].name);
jc.btr = (bt *)btt->ptr;
jc.virt = Index[server.dbid][jb->j_indxs[i]].virt;
if (w->low) { /* RANGE QUERY */
if (jc.virt) { /* PK */
btSIter *bi = btGetRangeIterator(jc.btr, w->low, w->high);
while ((be = btRangeNext(bi)) != NULL) {
jc.ajk = be->key;
jc.rrow = be->val;
joinAddColsFromInd(&jc, rset, w);
}
btReleaseRangeIterator(bi);
} else { /* FK */
robj *ind = Index[server.dbid][jb->j_indxs[i]].obj;
robj *ibtt = lookupKey(c->db, ind);
bt *ibtr = (bt *)ibtt->ptr;
btSIter *bi = btGetRangeIterator(ibtr, w->low, w->high);
while ((be = btRangeNext(bi)) != NULL) {
jc.ajk = be->key;
bt *nbtr = be->val;
btSIter *nbi = btGetFullRangeIterator(nbtr);
while ((nbe = btRangeNext(nbi)) != NULL) {
jc.rrow = btFindVal(jc.btr, nbe->key);
joinAddColsFromInd(&jc, rset, w);
}
btReleaseRangeIterator(nbi);
}
btReleaseRangeIterator(bi);
}
} else { /* IN() QUERY */
listNode *ln;
listIter *li = listGetIterator(w->inl, AL_START_HEAD);
if (jc.virt) {
while((ln = listNext(li)) != NULL) {
jc.ajk = ln->value;
jc.rrow = btFindVal(jc.btr, jc.ajk);
if (jc.rrow) joinAddColsFromInd(&jc, rset, w);
}
} else {
btSIter *nbi;
robj *ind = Index[server.dbid][jb->j_indxs[i]].obj;
robj *ibtt = lookupKey(c->db, ind);
bt *ibtr = (bt *)ibtt->ptr;
while((ln = listNext(li)) != NULL) {
jc.ajk = ln->value;
bt *nbtr = btIndFindVal(ibtr, jc.ajk);
if (nbtr) {
nbi = btGetFullRangeIterator(nbtr);
while ((nbe = btRangeNext(nbi)) != NULL) {
jc.rrow = btFindVal(jc.btr, nbe->key);
joinAddColsFromInd(&jc, rset, w);
}
btReleaseRangeIterator(nbi);
}
}
}
listReleaseIterator(li);
}
}
/* cant join if one table had ZERO rows */
bool one_empty = 0;
if (jbtr->numkeys == 0) one_empty = 1;
else {
for (int i = 1; i < jb->n_ind; i++) {
if (dictSize((dict *)rset[i]->ptr) == 0) {
one_empty = 1;
break;
}
}
}
LEN_OBJ
bool err = 0;
long sent = 0;
btIterator *bi = NULL; /* B4 GOTO */
char *reply = NULL; /* B4 GOTO */
if (!one_empty) {
int reply_size = 0;
for (int i = 0; i < jb->n_ind; i++) { // get maxlen possbl 4 joined row
reply_size += j_ind_len[i] + 1;
}
reply = malloc(reply_size); /* freed after while() loop */
build_jrow_reply_t bjr; /* none of these change during a join */
bzero(&bjr, sizeof(build_jrow_reply_t));
bjr.j.c = c;
bjr.j.jind_ncols = jind_ncols;
bjr.j.reply = reply;
bjr.j.csort_order = csort_order;
bjr.j.reordered = reordered;
bjr.j.qcols = jb->qcols;
bjr.n_ind = jb->n_ind;
bjr.card = &card;
bjr.j.obt = w->obt[0];
bjr.j.obc = w->obc[0];
bjr.j_indxs = jb->j_indxs;
bjr.j.ll = ll;
bjr.j.cstar = jb->cstar;
joinRowEntry *be;
bi = btGetJoinFullRangeIterator(jbtr, pk1type);
while ((be = btJoinRangeNext(bi, pk1type)) != NULL) { /* iter BT */
listNode *ln;
bjr.jk = be->key;
list *jll = (list *)be->val;
listIter *li = listGetIterator(jll, AL_START_HEAD);
while((ln = listNext(li)) != NULL) { /* iter LIST */
char *first_entry;
char *item = ln->value;
if (bjr.j.obt == Index[server.dbid][bjr.j_indxs[0]].table) {
obsl_t *ob = (obsl_t *)item;
Order_by_col_val = ob->keys[0];
first_entry = (char *)ob->row;
} else {
first_entry = item;
}
for (int j = 0; j < jind_ncols[0]; j++) {
Rcols[0][j] = (char **)first_entry;
first_entry += PTR_SIZE;
memcpy(&Rc_lens[0][j], first_entry, UINT_SIZE);
first_entry += UINT_SIZE;
}
if (!buildJRowReply(&bjr, 1, rset)) {
err = 1;
goto join_end;
}
}
listReleaseIterator(li);
}
if (Order_by) {
sent = sortJoinOrderByAndReply(c, &bjr, w);
if (sent == -1) err = 1;
releaseOBsort(ll);
}
}
join_end:
if (bi) btReleaseJoinRangeIterator(bi);
if (reply) free(reply);
/* free joinRowEntry malloc from joinAddColsFromInd() */
bool is_ob = (w->obt[0] == Index[server.dbid][jb->j_indxs[0]].table);
btJoinRelease(jbtr, jind_ncols[0], is_ob, freeListOfIndRow);
/* free joinRowEntry malloc from joinAddColsFromInd() */
dictEntry *de;
for (int i = 1; i < jb->n_ind; i++) {
dict *set = rset[i]->ptr;
bool is_ob = (w->obt[0] == Index[server.dbid][jb->j_indxs[i]].table);
dictIterator *di = dictGetIterator(set);
while((de = dictNext(di)) != NULL) {
robj *val = dictGetEntryVal(de);
dict *iset = val->ptr;
freeDictOfIndRow(iset, jind_ncols[i], is_ob);
}
dictReleaseIterator(di);
}
for (int i = 1; i < jb->n_ind; i++) {
decrRefCount(rset[i]);
}
if (err) return;
if (w->lim != -1 && sent < card) card = sent;
if (jb->cstar) {
lenobj->ptr = sdscatprintf(sdsempty(), ":%ld\r\n", card);
} else {
lenobj->ptr = sdscatprintf(sdsempty(), "*%ld\r\n", card);
if (w->ovar) incrOffsetVar(c, w, card);
}
}
robj *lookupKeyWrite(redisDb *db, robj *key) {
expireIfNeeded(db,key);
return lookupKey(db,key);
}
/* *
* slotscheck
* */
void
slotscheckCommand(redisClient *c) {
sds bug = NULL;
int i;
for (i = 0; i < HASH_SLOTS_SIZE && bug == NULL; i ++) {
dict *d = c->db->hash_slots[i];
if (dictSize(d) == 0) {
continue;
}
list *l = listCreate();
listSetFreeMethod(l, decrRefCountVoid);
unsigned long cursor = 0;
do {
cursor = dictScan(d, cursor, slotsScanSdsKeyCallback, l);
while (1) {
listNode *head = listFirst(l);
if (head == NULL) {
break;
}
robj *key = listNodeValue(head);
if (lookupKey(c->db, key) == NULL) {
if (bug == NULL) {
bug = sdsdup(key->ptr);
}
}
listDelNode(l, head);
}
} while (cursor != 0 && bug == NULL);
listRelease(l);
}
if (bug != NULL) {
addReplyErrorFormat(c, "step 1, miss = '%s'", bug);
sdsfree(bug);
return;
}
do {
dict *d = c->db->dict;
if (dictSize(d) == 0) {
break;
}
list *l = listCreate();
listSetFreeMethod(l, decrRefCountVoid);
unsigned long cursor = 0;
do {
cursor = dictScan(d, cursor, slotsScanSdsKeyCallback, l);
while (1) {
listNode *head = listFirst(l);
if (head == NULL) {
break;
}
robj *key = listNodeValue(head);
int slot = slots_num(key->ptr, NULL);
if (dictFind(c->db->hash_slots[slot], key->ptr) == NULL) {
if (bug == NULL) {
bug = sdsdup(key->ptr);
}
}
listDelNode(l, head);
}
} while (cursor != 0 && bug == NULL);
listRelease(l);
} while (0);
if (bug != NULL) {
addReplyErrorFormat(c, "step 2, miss = '%s'", bug);
sdsfree(bug);
return;
}
addReply(c, shared.ok);
}
value_t *lookupKeyWrite(memoryDb *db, sds *key) {
expireIfNeeded(db, key);
return lookupKey(db, key);
}
bool exists(size_t idx) const
{ return lookupKey(idx) != mIdxLookup.end(); }
static robj *lookupKeyRead(redisDb *db, robj *key) {
expireIfNeeded(db,key);
return lookupKey(db,key);
}
static robj *lookupKeyWrite(redisDb *db, robj *key) {
deleteIfVolatile(db,key);
return lookupKey(db,key);
}