com.elefana.document.psql.PsqlDocumentService Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of elefana-core Show documentation
null
The newest version!
/*******************************************************************************
 * Copyright 2018 Viridian Software Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package com.elefana.document.psql;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import com.elefana.api.AckResponse;
import com.elefana.api.document.*;
import com.elefana.api.indices.DeleteIndexRequest;
import org.postgresql.util.PGobject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Service;

import com.elefana.api.RequestExecutor;
import com.elefana.api.exception.DocumentAlreadyExistsException;
import com.elefana.api.exception.ElefanaException;
import com.elefana.api.exception.ShardFailedException;
import com.elefana.document.DocumentService;
import com.elefana.indices.IndexTemplateService;
import com.elefana.indices.psql.PsqlIndexFieldMappingService;
import com.elefana.node.NodeSettingsService;
import com.elefana.node.VersionInfoService;
import com.elefana.util.IndexUtils;
import com.jsoniter.JsonIterator;
import com.jsoniter.spi.TypeLiteral;

@Service
public class PsqlDocumentService implements DocumentService, RequestExecutor {
	private static final Logger LOGGER = LoggerFactory.getLogger(PsqlDocumentService.class);

	private static final long ONE_SECOND_IN_MILLIS = 1000L;
	private static final long ONE_MINUTE_IN_MILLIS = ONE_SECOND_IN_MILLIS * 60L;
	private static final long ONE_HOUR_IN_MILLIS = ONE_MINUTE_IN_MILLIS * 60L;
	private static final long ONE_DAY_IN_MILLIS = ONE_HOUR_IN_MILLIS * 24L;

	@Autowired
	private Environment environment;
	@Autowired
	private JdbcTemplate jdbcTemplate;
	@Autowired
	private IndexUtils indexUtils;
	@Autowired
	private NodeSettingsService nodeSettingsService;
	@Autowired
	private VersionInfoService versionInfoService;
	@Autowired
	private PsqlIndexFieldMappingService indexFieldMappingService;

	private ExecutorService executorService;

	@PostConstruct
	public void postConstruct() {
		final int totalThreads = environment.getProperty("elefana.service.document.threads", Integer.class,
				Runtime.getRuntime().availableProcessors());
		executorService = Executors.newFixedThreadPool(totalThreads);
	}

	@PreDestroy
	public void preDestroy() {
		executorService.shutdown();
	}

	@Override
	public GetRequest prepareGet(String index, String type, String id, boolean fetchSource) {
		final PsqlGetRequest getRequest = new PsqlGetRequest(this, index, type, id);
		getRequest.setFetchSource(fetchSource);
		return getRequest;
	}

	@Override
	public DeleteRequest prepareDelete(String index, String type, String id) {
		return new PsqlDeleteRequest(this, index, type, id);
	}

	@Override
	public DeleteIndexRequest prepareDeleteIndex(String indexPattern, String typePattern) {
		return new PsqlDeleteIndexRequest(this, indexPattern, typePattern);
	}

	@Override
	public MultiGetRequest prepareMultiGet(String requestBody) {
		return new PsqlMultiGetRequest(this, requestBody);
	}

	@Override
	public MultiGetRequest prepareMultiGet(String indexPattern, String requestBody) {
		final MultiGetRequest result = new PsqlMultiGetRequest(this, requestBody);
		result.setIndexPattern(indexPattern);
		return result;
	}

	@Override
	public MultiGetRequest prepareMultiGet(String indexPattern, String typePattern, String requestBody) {
		final MultiGetRequest result = new PsqlMultiGetRequest(this, requestBody);
		result.setIndexPattern(indexPattern);
		result.setTypePattern(typePattern);
		return result;
	}

	@Override
	public IndexRequest prepareIndex(String index, String type, String id, String document, IndexOpType opType) {
		final IndexRequest result = new PsqlIndexRequest(this);
		result.setIndex(index);
		result.setType(type);
		result.setId(id);
		result.setSource(document);
		result.setOpType(opType);
		return result;
	}

	public GetResponse get(GetRequest getRequest) throws ElefanaException {
		final GetResponse result = new GetResponse();
		result.setIndex(getRequest.getIndex());
		result.setType(getRequest.getType());
		result.setId(getRequest.getId());

		try {
			final String queryTarget = indexUtils.getQueryTarget(getRequest.getIndex());

			SqlRowSet resultSet;
			if (nodeSettingsService.isUsingCitus()) {
				if(getRequest.isFetchSource()) {
					String query = "SELECT * FROM " + queryTarget + " WHERE _type = ? AND _id = ?";
					resultSet = jdbcTemplate.queryForRowSet(query, getRequest.getType(), getRequest.getId());
				} else {
					String query = "SELECT _timestamp FROM " + queryTarget + " WHERE _type = ? AND _id = ?";
					resultSet = jdbcTemplate.queryForRowSet(query, getRequest.getType(), getRequest.getId());
				}
			} else {
				if(getRequest.isFetchSource()) {
					String query = "SELECT * FROM " + queryTarget + " WHERE _index = ? AND _type = ? AND _id = ?";
					resultSet = jdbcTemplate.queryForRowSet(query, getRequest.getIndex(), getRequest.getType(), getRequest.getId());
				} else {
					String query = "SELECT _timestamp FROM " + queryTarget + " WHERE _index = ? AND _type = ? AND _id = ?";
					resultSet = jdbcTemplate.queryForRowSet(query, getRequest.getIndex(), getRequest.getType(), getRequest.getId());
				}
			}

			if (resultSet.next()) {
				result.setVersion(1);
				result.setFound(true);

				if(getRequest.isFetchSource()) {
					result.setSource(JsonIterator.deserialize(IndexUtils.psqlUnescapeString(resultSet.getString("_source")),
							new TypeLiteral>() {
							}));
				} else {
					result.setSource(new HashMap());
				}
			} else {
				result.setFound(false);
			}
		} catch (Exception e) {
			e.printStackTrace();
			result.setFound(false);
		}
		return result;
	}

	public MultiGetResponse multiGet(String requestBody) throws ElefanaException {
		Map request = JsonIterator.deserialize(requestBody, new TypeLiteral>() {
		});
		List