User *SQLManager::findUser(std::string name, std::string pass) { std::string req; sqlite3_stmt *stmt; int s; req = "SELECT * FROM user WHERE login = ? AND pass = ?;"; stmt = NULL; if (sqlite3_prepare_v2(this->_db, req.c_str(), 50, &stmt, NULL) != SQLITE_OK) { std::cerr << "[ERROR] Erreur dans la recuperation d'une utilisateur." << std::endl; } sqlite3_bind_text(stmt, 1, name.c_str(), name.size(), NULL); sqlite3_bind_text(stmt, 2, pass.c_str(), pass.size(), NULL); s = sqlite3_step(stmt); if (s == SQLITE_DONE) return (NULL); else if (s == SQLITE_ROW) return (returnStats(stmt, name)); else return(NULL); return (NULL); }
/* * there are a variety of conditions that affect how FetchData is * going to work. This is an attempt to allow it to do as much * as possible, but not get overloaded. * summaryOnly is done when whole chrom summaries are requested * for statistic purposes. In those cases we do not need to go all * the way to the data to get the averages, the SQL rows are good * enough. Although even on this level there is quite a bit of * work to do on tracks such as Quality that have 180,000 rows on * just chr1. * a wiggleStats wsList is given when doing statistics, if it is * purely a data fetch operation, there is no need to do * wiggleStats and it will be a NULL pointer. * a bedList pointer is given when a returned bed list is desired. * In the case of processing a bedList, we honor the return limit * of number of bed elements via the maxBedElements. * If we are not returning a bedList and we are not doing a stats * summary, then we have an honest data fetch operation, and in * this case we honor the stated line limit of maxBedElements. * When the caller is doing this data fetch operation and states * that maxBedElements is zero, then we do all data that can be found. * This would be the case for a stats operation when only one chrom * is being worked on. */ struct wiggleData *wigFetchData(char *db, char *table, char *chromName, int winStart, int winEnd, boolean summaryOnly, boolean freeData, int tableId, boolean (*wiggleCompare)(int tableId, double value, boolean summaryOnly, struct wiggle *wiggle), char *constraints, struct bed **bedList, unsigned maxBedElements, struct wiggleStats **wsList) /* return linked list of wiggle data between winStart, winEnd */ { struct sqlConnection *conn = hAllocConn(db); struct sqlResult *sr; char **row; int rowOffset; int rowCount = 0; struct wiggle *wiggle; struct hash *spans = NULL; /* List of spans encountered during load */ char spanName[128]; char whereSpan[128]; char query[256]; struct hashEl *el; int leastSpan = BIGNUM; int mostSpan = 0; int spanCount = 0; int span = 0; struct hashCookie cookie; struct wiggleData *wigData = (struct wiggleData *) NULL; struct wiggleData *wdList = (struct wiggleData *) NULL; boolean bewareConstraints = FALSE; boolean createBedList = FALSE; boolean firstSpanDone = FALSE; unsigned dataLimit = 0; unsigned dataDone = 0; boolean reachedDataLimit = FALSE; /* make sure table exists before we try to talk to it * If it does not exist, we return a null result */ if (! sqlTableExists(conn, table)) { hFreeConn(&conn); return((struct wiggleData *)NULL); } if ((struct bed **)NULL != bedList) createBedList = TRUE; /* if we are not doing a summary (== return all data) and * we are not creating a bed list, then obey the limit requested * It will be zero if they really want everything. */ if (!summaryOnly && !createBedList) dataLimit = maxBedElements; spans = newHash(0); /* a listing of all spans found here */ resetStats(&wigStatsAcc); /* zero everything */ /* Are the constraints going to interfere with our span search ? */ if (constraints) { char *c = cloneString(constraints); tolowers(c); if (stringIn("span",c)) bewareConstraints = TRUE; } if (bewareConstraints) snprintf(query, sizeof(query), "SELECT span from %s where chrom = '%s' AND %s group by span", table, chromName, constraints ); else snprintf(query, sizeof(query), "SELECT span from %s where chrom = '%s' group by span", table, chromName ); /* Survey the spans to see what the story is here */ sr = sqlMustGetResult(conn,query); while ((row = sqlNextRow(sr)) != NULL) { unsigned span = sqlUnsigned(row[0]); ++rowCount; snprintf(spanName, sizeof(spanName), "%u", span); el = hashLookup(spans, spanName); if ( el == NULL) { if (span > mostSpan) mostSpan = span; if (span < leastSpan) leastSpan = span; ++spanCount; hashAddInt(spans, spanName, span); } } sqlFreeResult(&sr); /* Now, using that span list, go through each span, fetching data */ cookie = hashFirst(spans); while ((! reachedDataLimit) && (el = hashNext(&cookie)) != NULL) { if ((struct wiggleStats **)NULL != wsList) returnStats(&wigStatsAcc,wsList,chromName,winStart,winEnd,span); resetStats(&wigStatsAcc); if (bewareConstraints) { snprintf(whereSpan, sizeof(whereSpan), "((span = %s) AND %s)", el->name, constraints); } else snprintf(whereSpan, sizeof(whereSpan), "span = %s", el->name); span = atoi(el->name); sr = hOrderedRangeQuery(conn, table, chromName, winStart, winEnd, whereSpan, &rowOffset); rowCount = 0; while ((! reachedDataLimit) && (row = sqlNextRow(sr)) != NULL) { ++rowCount; wiggle = wiggleLoad(row + rowOffset); if (wiggle->count > 0 && (! reachedDataLimit)) { wigData = wigReadDataRow(wiggle, winStart, winEnd, tableId, summaryOnly, wiggleCompare ); if (wigData) { if (firstSpanDone) accumStats(&wigStatsAcc, wigData, (struct bed **)NULL, maxBedElements, table); else accumStats(&wigStatsAcc, wigData, bedList, maxBedElements, table); dataDone += wigData->count; if (freeData) { freeMem(wigData->data); /* and mark it gone */ wigData->data = (struct wiggleDatum *)NULL; } slAddHead(&wdList,wigData); if (!createBedList && dataLimit) if (dataLimit < dataDone) reachedDataLimit = TRUE; if (createBedList && (wigStatsAcc.bedElCount > maxBedElements)) reachedDataLimit = TRUE; } } } /* perhaps last bed line */ if (!firstSpanDone && createBedList && (wigStatsAcc.bedElEnd > wigStatsAcc.bedElStart) && wigData) { struct bed *bedEl; bedEl = bedElement(wigData->chrom, wigStatsAcc.bedElStart, wigStatsAcc.bedElEnd, table, ++wigStatsAcc.bedElCount); slAddHead(bedList, bedEl); } sqlFreeResult(&sr); firstSpanDone = TRUE; } closeWibFile(); if (createBedList) slReverse(bedList); /* last stats calculation */ if ((struct wiggleStats **)NULL != wsList) returnStats(&wigStatsAcc,wsList,chromName,winStart,winEnd,span); hFreeConn(&conn); if (wdList != (struct wiggleData *)NULL) slReverse(&wdList); /* this wdList can be freed by wigFreeData */ return(wdList); } /* struct wiggleData *wigFetchData() */