import org.lightcouch.CouchDbClient; //导入依赖的package包/类
protected List<String> loadDocsFromView(String viewId, String path,
		String sourcePath, String startKey, String endKey) {
	View view;

	List<String> allDocs = new Vector<String>();
	CouchDbClient dbClient = connectionProvider.getDBClient(CouchDbClient.class, path);
	try
	{
		view = dbClient.view(viewId);
		allDocs = view.includeDocs(false).startKey(startKey).endKey(endKey).query();
	} catch (NoDocumentException e)
	{
		e.printStackTrace();
		System.out.println("create view, view  id: " + viewId);
		createView(path, sourcePath, viewId);
		view = dbClient.view(viewId);
		allDocs = view.includeDocs(false).startKey(startKey).endKey(endKey).query();
	}
	return allDocs;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
protected InputStream loadViewIntoInputStream(String viewId, String path, String sourcePath) {
	View view;
	CouchDbClient dbClient = connectionProvider.getDBClient(CouchDbClient.class, path);
	InputStream inStream = null;
	try
	{
		view = dbClient.view(viewId);

	} catch (NoDocumentException e)
	{
		e.printStackTrace();
		System.out.println("create view, view id: " + viewId);
		createView(path, sourcePath, viewId);
		view = dbClient.view(viewId);
	}
	inStream = view.includeDocs(false).queryForStream();
	return inStream;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
protected List<String> loadDocsFromView(String viewId, String path, String sourcePath) {
	View view;
	List<String> allDocs = new Vector<String>();
	CouchDbClient dbClient = connectionProvider.getDBClient(CouchDbClient.class, path);
	try
	{

		view = dbClient.view(viewId);
		allDocs = view.includeDocs(true).query();
	} catch (NoDocumentException e)
	{
		e.printStackTrace();
		createView(path, sourcePath, viewId);
		view = dbClient.view(viewId);
		allDocs = view.includeDocs(true).query();
	}
	return allDocs;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
/**
 * Returns all OAuth tokens available in the database.
 *
 * @param req the http request
 * @return all OAuth tokens available in the database
 * @throws IOException if configuration cannot be accessed
 */
public static Map<String, String> getSocialToken(HttpServletRequest req) throws IOException {
    //noinspection ConstantConditions
    CouchDbClient dbClient = new CouchDbClient(CrawcialWebUtils.getCouchDbProperties(req.getServletContext(), Constants.CONFIGDB));
    Map<String, String> values = new HashMap<>();
    try {
        JsonObject o = dbClient.find(JsonObject.class, Constants.SOCIAL_KEYS);
        for (String k : Constants.keys) {
            if (o.has(k)) {
                values.put(k, o.get(k).getAsString());
            }
        }
    } catch (NoDocumentException | NullPointerException e) {
        System.out.println("No social config found");
    }
    return values;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
/**
 * Configures the DatabaseService singleton, must be called before the crawling process starts.
 *
 * @param downloadMedia true, if media downloader enabled, false to disable media downloads
 * @param dbProperties  CouchDB properties for the Crawcial Twitter Database
 * @param imgSize       requested image size (thumb, small, medium, large)
 * @param mediaHttps    true if https should be used for media downloads
 */
public synchronized void init(boolean downloadMedia, CouchDbProperties dbProperties, String imgSize, boolean mediaHttps) {
    DatabaseService.downloadMedia = downloadMedia;
    this.mediaHttps = mediaHttps;
    this.imgSize = imgSize;
    warningCnt = 0;
    this.dbProperties = dbProperties;
    CouchDbClient dbClient = new CouchDbCloneClient(dbProperties);
    DesignDocument designDoc = dbClient.design().getFromDesk("crawcial");
    dbClient.design().synchronizeWithDb(designDoc);
    dbClient.shutdown();

    attachmentExecutors = new LinkedBlockingQueue<>();
    if (downloadMedia) {
        es = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
                Runtime.getRuntime().availableProcessors() * 2, 30, TimeUnit.SECONDS, attachmentExecutors);
    }
    writeExecutor = new WriteExecutor(jsonObjectVector, bufferLimit);
    writeExecutorThread = new Thread(writeExecutor);
    writeExecutorThread.setName("writer-executor-thread-0");
    writeExecutorThread.start();
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
/**
 * Inserts defined amount of fake Tweets.
 *
 * @param amount amount of fake Tweets
 * @return duration in milliseconds
 */
long bench(int amount) {
    // Open database connection and take a timestamp
    CouchDbClient dbClient = new CouchDbCloneClient(properties);
    long startTime = System.currentTimeMillis();

    // Send generated JSON samples in bulk to database
    dbClient.bulk(generateSampleData(amount), true);

    // Take a second timestamp and perform some cleanup
    long duration = System.currentTimeMillis() - startTime;
    dbClient.context().ensureFullCommit();
    dbClient.context().deleteDB(properties.getDbName(), "delete database");
    dbClient.shutdown();
    return duration;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
private Stream<JsonObject> performMapReduce(String dbIP, String tableName, String mapRedDir)
{
  MapReduceSources mrs = MapReduceSources.fromDir(mapRedDir);
  CouchDbProperties properties = new CouchDbProperties(tableName.toLowerCase(), true, "http", dbIP, 5984, null, null);
  CouchDbClient dbClient = new CouchDbClient(properties);
  MapReduce mapRedObj = new MapReduce();
  mapRedObj.setMap(mrs.getMapJSCode());
  mapRedObj.setReduce(mrs.getReduceJSCode());
  List<JsonObject> list = dbClient.view("_temp_view").tempView(mapRedObj).group(true)
      .includeDocs(false).reduce(true).query(JsonObject.class);

  // This step will apply some custom rules to the elements...
  return adapter.adaptStream(list);
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
public boolean remove(E entity, String path, String revision) {
	if (entity == null)
		return false;
	
	CouchDbClient dbClient = connectionProvider.getDBClient(
			CouchDbClient.class, path);
	Response resp = dbClient.remove(entity.get_id(), revision);

	resp = dbClient.purge(path, entity.get_id(), new String[]{revision});
	System.out.println("remove object revision: " + entity.get_id() + ", repsonse: " + resp);
	return true;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public List<E> list(String path, String staticQueryId,
		String objectState) {
	List<String> allDocs = connectionProvider.getDBClient(CouchDbClient.class, path).view(staticQueryId)
			.includeDocs(true).query();
	ArrayList<BTSDBBaseObject> results = new ArrayList<BTSDBBaseObject>();
	Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("json", new JsResourceFactoryImpl());
	connectionProvider.getEmfResourceSet().getURIConverter().getURIHandlers().add(0, new CouchDBHandler());
	for (String jo : allDocs)
	{
		String id = extractIdFromObjectString(jo);
		logger.info(id);
		if (!id.startsWith("_"))
		{
			URI uri = URI.createURI(getLocalDBURL() + path + id);
			Resource resource = connectionProvider.getEmfResourceSet().getResource(uri, true);
			fillResource(resource, jo);
			E o = (E) resource.getContents().get(0);
			if (o instanceof BTSDBBaseObject)
			{
				checkForConflicts((E) o, path);
			}
			results.add(o);
		}
	}
	if (!results.isEmpty())
	{
		registerQueryIdWithInternalRegistry(BTSConstants.VIEW_ALL_DOCS, path);
	}
	return (List<E>) results;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public List<DBRevision> listAvailableRevisions(K key, String path) {
	CouchDbClient dbClient = connectionProvider.getDBClient(
			CouchDbClient.class, path);
	Params params = new Params();
	params.addParam("revs_info", "true");
	List<DBRevision> revisions = new Vector<DBRevision>();
	JsonObject jsonObject = dbClient.find(JsonObject.class, (String) key,
			params);
	for (JsonElement rev : jsonObject.getAsJsonArray("_revs_info")) {
		JsonElement rev_info = rev.getAsJsonObject().get("rev");
		String docRev = rev_info.getAsString();
		JsonElement rev_av = rev.getAsJsonObject().get("status");
		String rev_av_str = rev_av.getAsString();
		DBRevision r = new DBRevision();
		r.setRevision(docRev);
		if ("available".equals(rev_av_str))
		{
			r.setLocation(DBRevision.LOCAL);
		}
		else
		{
			r.setLocation(DBRevision.NOT_AVAILABLE);
		}
		revisions.add(r);
	}
	return revisions;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public void checkForConflicts(E object, String path) {
	if (object == null) return;
	CouchDbClient dbClient = connectionProvider.getDBClient(
			CouchDbClient.class, path != null ? path : object.getDBCollectionKey());
	List<String> conflicts = dbClient.listConflictingRevs(path, object.get_id());
	object.getConflictingRevs().addAll(conflicts);
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
public void createView(String path, String sourcePath, String viewName)
{
	logger.info("path " + path + " viewName " + viewName);
	CouchDbClient dbClient = connectionProvider.getDBClient(CouchDbClient.class, path);
	// design documents stored on local .js files

	DesignDocument designDoc = dbClient.design().getFromDesk(sourcePath);
	// designDoc.new DesignDocument();//
	dbClient.design().synchronizeWithDb(designDoc); // sync with db
	// dbClient.syncDesignDocsWithDb(); // sync all
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public boolean removeDBLease(DBLease lease, String path)
{
	CouchDbClient dbClient = connectionProvider.getDBClient(
			CouchDbClient.class, path);
	Response resp = null;
	if (lease.get_rev() != null)
	{
		try {
			resp = dbClient.remove(lease.get_id(), lease.get_rev());
		} catch (Exception e) {
			DBLease entity2 = reload(lease.get_id(), path);
			if (entity2 != null)
			{
				lease = entity2;
				resp = dbClient.remove(lease.get_id(), lease.get_rev());
			}
		}
	}
	String rev = null;
	if (resp != null)
	{
		rev = resp.getRev();
	}
	else
	{
		rev = lease.get_rev();
	}
	dbClient.purge(path, lease.get_id(), new String[]{rev});
	return true;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public boolean removeDatabaseUser(BTSUser user) {
	CouchDbClient dbClient = connectionProvider.getDBClient(
			CouchDbClient.class, _USERS);
	try {
		dbClient.remove(COUCHDB_USERS_PREFIX + user.getUserName());
		return true;
	} catch (Exception e) {
		e.printStackTrace();
		return false;
	}
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public void purgeDBConnectionPool() {
	Map<String, CouchDbClient> clients = (Map<String, CouchDbClient>) context.get(DaoConstants.DB_CLIENT_POOL_MAP);
	if (clients == null)
	{
		return;
	}
	clients.clear();
	
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public boolean checkUserIsDBAdmin(String userName, String password) {
	CouchDbClient dbClient = null;
	boolean success = true;
	try {
		dbClient = connectionProvider.getDBClient(CouchDbClient.class,
				"_users");
		dbClient.design().getFromDb("_all_docs");
	} catch (Exception e) {
		success = false;
	}
	return success;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@Override
public boolean dbCollectionExists(String dbCollectionName) {
	CouchDbClient dbClient = null;
	boolean exists = true;
	try {
		dbClient = connectionProvider.getDBClient(CouchDbClient.class,
				dbCollectionName);
		dbClient.context().info().getDocCount();
	} catch (Exception e) {
		exists = false;
	}
	return exists;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
public static int fetchAndIndexChangesSeq(String collection, BulkProcessor bulkProcessor, Client esClient, CouchDbClient dbClient, int seq, IProgressMonitor monitor, Logger logger)
{
	List<String> lines = fetchLine(collection, dbClient, seq);
	Object returnSeq = processLines(lines, collection, bulkProcessor, monitor, logger);
	if (returnSeq instanceof String)
	{
		seq = new Integer(((String) returnSeq)).intValue();
	}
	return seq;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
private static List<String> fetchLine(String collection, CouchDbClient dbClient,
		int seq) {
	ChangesResult cr = dbClient.changes().includeDocs(true).since(new Integer(seq).toString()).getChanges();
	List<Row> rows = cr.getResults();
	List<String> lines = new Vector<String>(rows.size());

	for (Row row : rows)
	{
		lines.add(row.getDoc().toString());
	}
	// TODO Auto-generated method stub
	return lines;
}
 

import org.lightcouch.CouchDbClient; //导入依赖的package包/类
@SuppressWarnings("unchecked")
	@Override
	public E find(K key, String path, String revision)
	{
		CouchDbClient dbClient = connectionProvider.getDBClient(
				CouchDbClient.class, path);
		URI uri = URI.createURI(getRemoteDBURL() + "/" + path + "/" + key + "?rev=" + revision);
		Resource tempResource = connectionProvider.getEmfResourceSet().createResource(uri);
		InputStream stream = dbClient.find((String)key, revision);
		
		final JSONLoad loader = new JSONLoad(stream,
				new HashMap<Object, Object>(), connectionProvider.getEmfResourceSet());
		loader.fillResource(tempResource);
		
//		EObjectMapper objectMapper = new EObjectMapper();
//		Object o = objectMapper.from(stream, tempResource, null);
//		String content = CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8));
//		Closeables.closeQuietly(stream);
//		loadResourceFromString(key + revision, content, indexName)
//		EObject objects = loadObjectFromHit(hit, indexName)sFromInputStream(connectionProvider.getEmfResourceSet(), content);
		if (!tempResource.getContents().isEmpty())
		{
			Object o =  tempResource.getContents().iterator().next();
			if (o instanceof BTSDBBaseObject)
			{
				return (E)o;
			}
		}
		return null;
		
	}