static int fetchExecuteResult(struct nuodb *db, Statement *stmt, int64_t *rows_affected, int64_t *last_insert_id) { ResultSet *resultSet = 0; try { resultSet = stmt->getGeneratedKeys(); // NuoDB uses -1 as a flag for zero-rows-affected *rows_affected = std::max(0, stmt->getUpdateCount()); if (*rows_affected > 0 && resultSet->getMetaData()->getColumnCount() > 0) { while (resultSet->next()) { // TODO find out how to read the last id first } switch (resultSet->getMetaData()->getColumnType(1)) { case NUOSQL_TINYINT: case NUOSQL_SMALLINT: case NUOSQL_INTEGER: case NUOSQL_BIGINT: case NUOSQL_FLOAT: case NUOSQL_DOUBLE: case NUOSQL_NUMERIC: case NUOSQL_DECIMAL: *last_insert_id = resultSet->getLong(1); break; default: // This is to avoid a failure when trying to call resultSet->getLong() when // the generated column has a string type and a default sequence. If the user // passes a string that cannot be converted to long, an exception is thrown. // // Since this only happens when the string is user-provided, we don't need to // worry about trying to parse the returned value to return to the user. // // See TestStringSequence for more details. *last_insert_id = 0; break; } } else { *last_insert_id = 0; } resultSet->close(); return 0; } catch (SQLException &e) { if (resultSet) { resultSet->close(); } return setError(db, e); } }
int nuodb_resultset_column_names(struct nuodb *db, struct nuodb_resultset *rs, struct nuodb_value names[]) { ResultSet *resultSet = reinterpret_cast<ResultSet *>(rs); try { ResultSetMetaData *resultSetMetaData = resultSet->getMetaData(); int columnCount = resultSetMetaData->getColumnCount(); for (int i=0; i < columnCount; ++i) { int columnIndex = i+1; const char *string = resultSetMetaData->getColumnLabel(columnIndex); names[i].i64 = reinterpret_cast<int64_t>(string); names[i].i32 = std::strlen(string); } return 0; } catch (SQLException &e) { return setError(db, e); } }
bool validateTokenByName(string user, string token) { PreparedStatement * prepstmt; prepstmt = conn -> prepareStatement("select ((select expiry from tokens where (userid=(select id from users where login=?) and token=?)) > now() is true) as res;"); prepstmt->setString(1, user); prepstmt->setString(2, token); try { ResultSet * rs; rs = prepstmt->executeQuery(); string a = rs->getMetaData()->getColumnLabel(1); rs->next(); if(rs->getBoolean(a))return true; throw 3; } catch(exception e) { throw 2; } }
int nuodb_statement_query(struct nuodb *db, struct nuodb_statement *st, struct nuodb_resultset **rs, int *column_count) { ResultSet *resultSet = 0; PreparedStatement *stmt = reinterpret_cast<PreparedStatement *>(st); try { bool hasResults = stmt->execute(); if (hasResults) { resultSet = stmt->getResultSet(); } else { resultSet = stmt->getGeneratedKeys(); } *column_count = resultSet->getMetaData()->getColumnCount(); *rs = reinterpret_cast<struct nuodb_resultset *>(resultSet); return 0; } catch (SQLException &e) { if (resultSet) { resultSet->close(); } return setError(db, e); } }
static int fetchExecuteResult(struct nuodb *db, Statement *stmt, int64_t *rows_affected, int64_t *last_insert_id) { ResultSet *resultSet = 0; try { resultSet = stmt->getGeneratedKeys(); // NuoDB uses -1 as a flag for zero-rows-affected *rows_affected = std::max(0, stmt->getUpdateCount()); if (*rows_affected > 0 && resultSet->getMetaData()->getColumnCount() > 0) { while (resultSet->next()) { // TODO find out how to read the last id first } *last_insert_id = resultSet->getLong(1); } else { *last_insert_id = 0; } resultSet->close(); return 0; } catch (SQLException &e) { if (resultSet) { resultSet->close(); } return setError(db, e); } }
int nuodb_resultset_next(struct nuodb *db, struct nuodb_resultset *rs, int *has_values, struct nuodb_value values[]) { ResultSet *resultSet = reinterpret_cast<ResultSet *>(rs); try { *has_values = resultSet->next(); if (*has_values) { ResultSetMetaData *resultSetMetaData = resultSet->getMetaData(); int columnCount = resultSetMetaData->getColumnCount(); for (int i=0; i < columnCount; ++i) { int64_t i64 = 0; int32_t i32 = 0; enum nuodb_value_type vt = NUODB_TYPE_NULL; int columnIndex = i+1; switch (resultSetMetaData->getColumnType(columnIndex)) { case NUOSQL_NULL: vt = NUODB_TYPE_NULL; break; case NUOSQL_TINYINT: case NUOSQL_SMALLINT: case NUOSQL_INTEGER: case NUOSQL_BIGINT: if (resultSetMetaData->getScale(columnIndex) == 0) { i64 = resultSet->getLong(columnIndex); if (!resultSet->wasNull()) { vt = NUODB_TYPE_INT64; } break; } // fallthrough; must be fetched as a string case NUOSQL_NUMERIC: case NUOSQL_DECIMAL: { const char *string = resultSet->getString(columnIndex); if (!resultSet->wasNull()) { vt = NUODB_TYPE_BYTES; // strings are returned as bytes i64 = reinterpret_cast<int64_t>(string); i32 = std::strlen(string); } break; } case NUOSQL_FLOAT: case NUOSQL_DOUBLE: { union { double float64; int64_t i64; } value = { resultSet->getDouble(columnIndex) }; if (!resultSet->wasNull()) { vt = NUODB_TYPE_FLOAT64; i64 = value.i64; } break; } case NUOSQL_BIT: case NUOSQL_BOOLEAN: i64 = resultSet->getBoolean(columnIndex); if (!resultSet->wasNull()) { vt = NUODB_TYPE_BOOL; } break; case NUOSQL_DATE: case NUOSQL_TIME: case NUOSQL_TIMESTAMP: { Timestamp *ts = resultSet->getTimestamp(columnIndex); if (ts && !resultSet->wasNull()) { vt = NUODB_TYPE_TIME; i64 = ts->getSeconds(); i32 = ts->getNanos(); } break; } default: { const Bytes b = resultSet->getBytes(columnIndex); if (!resultSet->wasNull()) { vt = NUODB_TYPE_BYTES; i64 = reinterpret_cast<int64_t>(b.data); i32 = b.length; } break; } } values[i].i64 = i64; values[i].i32 = i32; values[i].vt = vt; } } return 0; } catch (SQLException &e) { return setError(db, e); } }
/** * * Executes a query and returns the result * * @param VariantVector arguments The query arguments. The first argument should * be the query and any subsequent arguments are the bind parameters * * @return The results from the query */ QueryResult DatabaseConnection::execute(VariantVector arguments) { int i; int count; QueryResult result; ResultSet *sqlResult; ResultSetMetaData *sqlMetadata; result = connect(); if (result.error.isError) { // There was an error connecting. Return the result. return result; } PreparedStatement *sqlStatement = nullptr; try { // Prepare query sqlStatement = connection->prepareStatement( arguments.front().toString()); if (arguments.size() > 1) { // Bind arguments int i = 1; for (auto it = arguments.begin() + 1; it != arguments.end(); ++it) { sqlStatement->setString(i, it->toString()); i++; } } // Execute query sqlStatement->execute(); // Fetch results sqlResult = sqlStatement->getResultSet(); } catch (SQLException &e) { if (sqlStatement != nullptr) { // Free memory delete sqlStatement; } result.error.isError = true; result.error.code = e.getErrorCode(); result.error.string = e.getSQLState() + ": " + e.what(); return result; } sqlMetadata = sqlResult->getMetaData(); count = sqlMetadata->getColumnCount(); for (i = 1; i <= count; i++) { // Add to collection result.columns.push_back(sqlMetadata->getColumnName(i).asStdString()); } // Read rows while (sqlResult->next()) { VariantVector row; for (i = 1; i <= count; i++) { Variant column; switch (sqlMetadata->getColumnType(i)) { default: case ::DataType::UNKNOWN: case ::DataType::CHAR: case ::DataType::VARCHAR: case ::DataType::LONGVARCHAR: case ::DataType::BINARY: case ::DataType::VARBINARY: case ::DataType::LONGVARBINARY: case ::DataType::TIMESTAMP: case ::DataType::DATE: case ::DataType::GEOMETRY: case ::DataType::ENUM: case ::DataType::SET: case ::DataType::BIGINT: case ::DataType::REAL: case ::DataType::DOUBLE: case ::DataType::DECIMAL: // @TODO: store binary, timestamp, date, & geometry differently // Also numeric types (need to be added to Variant class) column = sqlResult->getString(i).asStdString(); break; case ::DataType::SQLNULL: column = Variant(); break; case ::DataType::BIT: case ::DataType::TINYINT: case ::DataType::SMALLINT: case ::DataType::MEDIUMINT: case ::DataType::INTEGER: case ::DataType::NUMERIC: column = sqlResult->getInt(i); break; case ::DataType::YEAR: column = static_cast<unsigned short>(sqlResult->getUInt(i)); break; } // Add column to collection row.push_back(column); } // Add row to collection result.rows.push_back(row); } // Free memory delete sqlResult; delete sqlStatement; return result; }