Java Cursor.next方法代码示例

import com.mongodb.Cursor; //导入方法依赖的package包/类
public HashSet<Integer> getDistributionsByObjectNS(String nsToSearch) {

		BasicDBObject query = new BasicDBObject(DistributionObjectNS0DB.NS, nsToSearch);
		DBCollection collection = DBSuperClass2.getDBInstance().getCollection(DistributionObjectNS0DB.COLLECTION_NAME);

		HashSet<Integer> hash = new HashSet<Integer>();

		Cursor cursor = collection.find(query);

		while (cursor.hasNext()) {
			DBObject instance = cursor.next();
//			DistributionDB distribution = new DistributionDB(
//					((Number) instance.get(DistributionSubjectNS0DB.DISTRIBUTION_ID)).intValue());
//
//			if (distribution.getTriples() >= 1000)
				hash.add(((Number) instance.get(DistributionObjectNS0DB.DISTRIBUTION_ID)).intValue());
		}

		return hash;
	}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Album> getAlbumsByTitle(String title) throws SQLException {
	ArrayList<Album> result = new ArrayList<Album>();
	DBCollection collection = db.getCollection("Media");

	DBObject query = new BasicDBObject("Title", title);
	Pattern regex = Pattern.compile(title);
	query.put("Title", regex);

	/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
	DBObject mediatype = new BasicDBObject("Mediatype", "Album");
	BasicDBList and = new BasicDBList();
	and.add(mediatype);
	and.add(query);
	query = new BasicDBObject("$and", and);
	/* -------------- END MEDIATYPE LIMITER ------------------------ */

	Cursor cursor = collection.find(query);
	System.out.println("Searching by title " + title + " ...");
	while (cursor.hasNext()) {
		BasicDBObject dbo = (BasicDBObject) cursor.next();
		Album a = Objectifier.cursorToAlbum(dbo);
		result.add(a);
	}
	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Album> getAlbumsByGenre(String genre) throws SQLException {
	ArrayList<Album> result = new ArrayList<Album>();
	DBCollection collection = db.getCollection("Media");
	DBObject query = new BasicDBObject("Genre", genre);
	Pattern regex = Pattern.compile(genre);
	query.put("Genre", regex);

	/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
	DBObject mediatype = new BasicDBObject("Mediatype", "Album");
	BasicDBList and = new BasicDBList();
	and.add(mediatype);
	and.add(query);
	query = new BasicDBObject("$and", and);
	/* -------------- END MEDIATYPE LIMITER ------------------------ */

	Cursor cursor = collection.find(query);
	System.out.println("Searching by genre " + genre + " ...");
	while (cursor.hasNext()) {
		BasicDBObject dbo = (BasicDBObject) cursor.next();
		Album a = Objectifier.cursorToAlbum(dbo);
		result.add(a);
	}
	System.out.println(result);
	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Movie> getMovieByTitle(String title) throws SQLException {
	ArrayList<Movie> result = new ArrayList<Movie>();
	DBCollection collection = db.getCollection("Media");

	DBObject query = new BasicDBObject("Title", title);
	Pattern regex = Pattern.compile(title);
	query.put("Title", regex);

	/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
	DBObject mediatype = new BasicDBObject("Mediatype", "Movie");
	BasicDBList and = new BasicDBList();
	and.add(mediatype);
	and.add(query);
	query = new BasicDBObject("$and", and);
	/* -------------- END MEDIATYPE LIMITER ------------------------ */

	Cursor cursor = collection.find(query);
	System.out.println("Searching by title " + title + " ...");
	while (cursor.hasNext()) {
		BasicDBObject dbo = (BasicDBObject) cursor.next();
		Movie a = Objectifier.cursorToMovie(dbo);
		result.add(a);
	}
	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Movie> getMovieByGenre(String genre) throws SQLException {
	ArrayList<Movie> result = new ArrayList<Movie>();
	DBCollection collection = db.getCollection("Media");
	DBObject query = new BasicDBObject("Genre", genre);
	Pattern regex = Pattern.compile(genre);
	query.put("Genre", regex);

	/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
	DBObject mediatype = new BasicDBObject("Mediatype", "Movie");
	BasicDBList and = new BasicDBList();
	and.add(mediatype);
	and.add(query);
	query = new BasicDBObject("$and", and);
	/* -------------- END MEDIATYPE LIMITER ------------------------ */

	Cursor cursor = collection.find(query);
	System.out.println("Searching by genre " + genre + " ...");
	while (cursor.hasNext()) {
		BasicDBObject dbo = (BasicDBObject) cursor.next();
		Movie a = Objectifier.cursorToMovie(dbo);
		result.add(a);
	}
	System.out.println(result);
	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public EnsemblTranscript findOneByHugoSymbolIgnoreCase(String hugoSymbol, String isoformOverrideSource) {
    BasicDBObject regexQuery = new BasicDBObject();
    // case insensitive exact match query
    regexQuery.put("hgnc_symbol",
        new BasicDBObject("$regex", "^" + hugoSymbol + "$")
            .append("$options", "i"));

    Cursor transcriptCursor;
    Cursor canonicalCursor = mongoTemplate.getCollection(CANONICAL_TRANSCRIPTS_COLLECTION).find(regexQuery);

    if (canonicalCursor.hasNext()) {
        BasicDBObject canonicalTranscriptsPerSource = (BasicDBObject) canonicalCursor.next();

        String transcriptId = (String) canonicalTranscriptsPerSource.get(isoformOverrideSource + "_canonical_transcript");

        BasicDBObject whereQuery = new BasicDBObject();
        whereQuery.put(EnsemblTranscript.TRANSCRIPT_ID_FIELD_NAME, transcriptId);

        transcriptCursor = mongoTemplate.getCollection(TRANSCRIPTS_COLLECTION).find(whereQuery);
        if (transcriptCursor.hasNext()) {
           EnsemblTranscript transcript = mongoTemplate.getConverter().read(EnsemblTranscript.class, transcriptCursor.next());
            if (transcript != null) {
                return transcript;
            }
        }
    }
    return null;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Album> getAllAlbums(ResultSet rsetAlbum)
		throws SQLException {
	ArrayList<Album> albums = new ArrayList<Album>();

	Cursor cr = coll.find();

	while (cr.hasNext()) {
		cr.next();
	}

	return albums;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Album> getAlbumsByYear(String year) throws SQLException {
	// TODO ADD TRYCATCH FOR CORRECT EXCEPTION researching API
	ArrayList<Album> result = new ArrayList<Album>();

	DBCollection collection = db.getCollection("Media");
	DBObject query = new BasicDBObject("Year", year);
	Pattern regex = Pattern.compile(year);
	query.put("Year", regex);

	/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
	DBObject mediatype = new BasicDBObject("Mediatype", "Album");
	BasicDBList and = new BasicDBList();
	and.add(mediatype);
	and.add(query);
	query = new BasicDBObject("$and", and);
	/* -------------- END MEDIATYPE LIMITER ------------------------ */

	Cursor cursor = collection.find(query);
	System.out.println("Searching by year " + year + " ...");
	while (cursor.hasNext()) {
		BasicDBObject dbo = (BasicDBObject) cursor.next();
		// Make Album from result of query
		Album a = Objectifier.cursorToAlbum(dbo);
		// System.out.println(a.toString());

		// put in list
		result.add(a);
	}
	System.out.println("Done searching ...");

	// DEBUG: print them out

	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Album> getAlbumsByUser(String user) throws SQLException {
	ArrayList<Album> result = new ArrayList<Album>();
	try {
		DBCollection collection = db.getCollection("Media");
		DBObject query = new BasicDBObject("AddedBy", user);
		Pattern regex = Pattern.compile(user);
		query.put("AddedBy", regex);

		/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
		DBObject mediatype = new BasicDBObject("Mediatype", "Album");
		BasicDBList and = new BasicDBList();
		and.add(mediatype);
		and.add(query);
		query = new BasicDBObject("$and", and);
		/* -------------- END MEDIATYPE LIMITER ------------------------ */

		Cursor cursor = collection.find(query);
		System.out.println("Searching by user " + user + " ...");
		while (cursor.hasNext()) {
			BasicDBObject dbo = (BasicDBObject) cursor.next();
			// Make Album from result of query
			Album a = Objectifier.cursorToAlbum(dbo);
			// System.out.println(a.toString());

			// put in list
			result.add(a);
		}
	} catch (Exception e) {
		// TODO: handle exception
		e.printStackTrace();
	}
	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Movie> getMovieByUser(String user) throws SQLException {
	ArrayList<Movie> result = new ArrayList<Movie>();
	try {
		DBCollection collection = db.getCollection("Media");
		DBObject query = new BasicDBObject("AddedBy", user);
		Pattern regex = Pattern.compile(user);
		query.put("AddedBy", regex);

		/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
		DBObject mediatype = new BasicDBObject("Mediatype", "Movie");
		BasicDBList and = new BasicDBList();
		and.add(mediatype);
		and.add(query);
		query = new BasicDBObject("$and", and);
		/* -------------- END MEDIATYPE LIMITER ------------------------ */

		Cursor cursor = collection.find(query);
		System.out.println("Searching by user " + user + " ...");
		while (cursor.hasNext()) {
			BasicDBObject dbo = (BasicDBObject) cursor.next();
			// Make Album from result of query
			Movie m = Objectifier.cursorToMovie(dbo);
			// System.out.println(a.toString());

			// put in list
			result.add(m);
		}
	} catch (Exception e) {
		// TODO: handle exception
		e.printStackTrace();
	}
	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Movie> getAllMovies(ResultSet rsetMovie)
		throws SQLException {
	ArrayList<Movie> movies = new ArrayList<Movie>();

	Cursor cr = coll.find();

	while (cr.hasNext()) {
		cr.next();
	}

	return movies;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public ArrayList<Movie> getMovieByYear(String year) throws SQLException {
	// TODO ADD TRYCATCH FOR CORRECT EXCEPTION researching API
	ArrayList<Movie> result = new ArrayList<Movie>();

	DBCollection collection = db.getCollection("Media");
	DBObject query = new BasicDBObject("Year", year);
	Pattern regex = Pattern.compile(year);
	query.put("Year", regex);

	/* --------------- ADDED MEDIATYPE LIMITER ---------------------- */
	DBObject mediatype = new BasicDBObject("Mediatype", "Movie");
	BasicDBList and = new BasicDBList();
	and.add(mediatype);
	and.add(query);
	query = new BasicDBObject("$and", and);
	/* -------------- END MEDIATYPE LIMITER ------------------------ */

	Cursor cursor = collection.find(query);
	System.out.println("Searching by year " + year + " ...");
	while (cursor.hasNext()) {
		BasicDBObject dbo = (BasicDBObject) cursor.next();
		// Make Album from result of query
		Movie m = Objectifier.cursorToMovie(dbo);
		// System.out.println(a.toString());

		// put in list
		result.add(m);
	}
	System.out.println("Done searching ...");

	// DEBUG: print them out

	return result;
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
@Override
public void getReviewsByAny(String queryText) throws SQLException {
	queryText = queryText.replace("%", "");
	ArrayList<Review> reviews = new ArrayList<Review>();
	DBCollection collection = db.getCollection("Media");
	Pattern regex = Pattern.compile(queryText);

	DBObject st1 = new BasicDBObject("Review.Title", regex);
	DBObject st2 = new BasicDBObject("Review.Text", regex);
	DBObject st3 = new BasicDBObject("Review.User", regex);
	DBObject st4 = new BasicDBObject("Mediatype", regex);
	DBObject st5 = new BasicDBObject("Title", regex);
	BasicDBList or = new BasicDBList();
	or.add(st1);
	or.add(st2);
	or.add(st3);
	or.add(st4);
	or.add(st5);
	DBObject query = new BasicDBObject("$or", or);

	Cursor cursor = collection.find(query);
	System.out.println("Searching by Review " + queryText + " ...");
	while (cursor.hasNext()) {
		BasicDBObject dbo = (BasicDBObject) cursor.next();
		reviews.addAll(Objectifier.cursorToReview(dbo, queryText));
	}

	System.out.println("Searching by review...");
	model.setBank(reviews.toArray());
}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
public HashSet<Integer> getDistributionsBySubjectNS(String nsToSearch) {

		BasicDBObject query = new BasicDBObject(DistributionSubjectNS0DB.NS, nsToSearch);

		DBCollection collection = DBSuperClass2.getDBInstance().getCollection(DistributionSubjectNS0DB.COLLECTION_NAME);

		HashSet<Integer> hash = new HashSet<Integer>();

		Cursor cursor = collection.find(query);

		while (cursor.hasNext()) {
			DBObject instance = cursor.next();

//			DistributionDB distribution = new DistributionDB(
//					((Number) instance.get(DistributionSubjectNS0DB.DISTRIBUTION_ID)).intValue());
//
//			if (distribution.getTriples() >= 1000)
				hash.add(((Number) instance.get(DistributionSubjectNS0DB.DISTRIBUTION_ID)).intValue());
		}

		return hash;
	}
 

import com.mongodb.Cursor; //导入方法依赖的package包/类
public ArrayList<DistributionDB> getDistributionsByOutdegree(ArrayList<String> nsToSearch,
		ConcurrentHashMap<Integer, DistributionBloomFilterContainer> distributionFilter) {
	ArrayList<DistributionDB> list = new ArrayList<DistributionDB>();

	try {

		// query all NS
		BasicDBObject query = new BasicDBObject(DistributionSubjectNS0DB.NS, new BasicDBObject("$in", nsToSearch));

		DBCollection collection = DBSuperClass2.getDBInstance()
				.getCollection(DistributionSubjectNS0DB.COLLECTION_NAME);

		// group by
		Cursor cursor = collection
				.aggregate(Arrays.asList(
						new BasicDBObject("$match",
								new BasicDBObject(DistributionSubjectNS0DB.NS,
										new BasicDBObject("$in", nsToSearch))),
						new BasicDBObject("$group",
								new BasicDBObject("_id", "$" + DistributionSubjectNS0DB.DISTRIBUTION_ID))

		), aggregationOptions);

		// save a list with distribution and fqdn
		while (cursor.hasNext()) {
			DBObject instance = cursor.next();

			DistributionDB distribution = new DistributionDB();
			distribution.setLodVaderID(((Number) instance.get("_id")).intValue());
			if (distribution.find(true)) {
				list.add(distribution);
				if (!distributionFilter.containsKey(distribution.getLODVaderID())) {
					distributionFilter.put(distribution.getLODVaderID(),
							new DistributionBloomFilterContainer(distribution.getLODVaderID()));
				}
			}

		}

	} catch (Exception e) {
		e.printStackTrace();
	}
	return list;
}