• Home
• com.axibase
• atsd-jdbc
• 1.2.6
• source code
• AtsdMeta.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.axibase.tsd.driver.jdbc.ext.AtsdMeta Maven / Gradle / Ivy

/*
* Copyright 2016 Axibase Corporation or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* https://www.axibase.com/atsd/axibase-apache-2.0.pdf
*
* or in the "license" file accompanying this file. This file 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.axibase.tsd.driver.jdbc.ext;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.security.GeneralSecurityException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.sql.Types;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.TimeZone;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.calcite.avatica.AvaticaConnection;
import org.apache.calcite.avatica.AvaticaUtils;
import org.apache.calcite.avatica.ColumnMetaData;
import org.apache.calcite.avatica.ConnectionConfig;
import org.apache.calcite.avatica.Meta;
import org.apache.calcite.avatica.MetaImpl;
import org.apache.calcite.avatica.MissingResultsException;
import org.apache.calcite.avatica.NoSuchStatementException;
import org.apache.calcite.avatica.QueryState;
import org.apache.calcite.avatica.remote.TypedValue;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.text.WordUtils;

import com.axibase.tsd.driver.jdbc.DriverConstants;
import com.axibase.tsd.driver.jdbc.content.ContentDescription;
import com.axibase.tsd.driver.jdbc.content.ContentMetadata;
import com.axibase.tsd.driver.jdbc.content.DataProvider;
import com.axibase.tsd.driver.jdbc.content.StatementContext;
import com.axibase.tsd.driver.jdbc.intf.IDataProvider;
import com.axibase.tsd.driver.jdbc.intf.IStoreStrategy;
import com.axibase.tsd.driver.jdbc.logging.LoggingFacade;

public class AtsdMeta extends MetaImpl {
	private static final LoggingFacade log = LoggingFacade.getLogger(AtsdMeta.class);
	private static final int TIMESTAMP_LENGTH = "2016-01-01T00:00:00.000".length();
	private final AtomicInteger idGenerator = new AtomicInteger(1);
	private final Map metaCache = new ConcurrentHashMap<>();
	private final Map providerCache = new ConcurrentHashMap<>();
	private final Map contextMap = new ConcurrentHashMap<>();
	private final ReentrantLock lock = new ReentrantLock();

	public AtsdMeta(final AvaticaConnection conn) {
		super(conn);
		this.connProps.setAutoCommit(true);
		this.connProps.setReadOnly(true);
		this.connProps.setTransactionIsolation(Connection.TRANSACTION_NONE);
		this.connProps.setDirty(false);
	}

	public StatementContext getContextFromMap(StatementHandle h) {
		return contextMap.get(h.id);
	}

	@Override
	public StatementHandle prepare(ConnectionHandle ch, String query, long maxRowCount) {
		try {
			lock.lockInterruptibly();
		} catch (InterruptedException e) {
			if (log.isDebugEnabled())
				log.debug("[prepare] " + e.getMessage());
		}
		final int id = idGenerator.getAndIncrement();
		if (log.isTraceEnabled()) {
			log.trace("[prepare] locked: {} handle: {} query: {}", lock.getHoldCount(), id, query);
		}
		try {
			final IDataProvider provider = initProvider(id, query);
			provider.checkScheme(query);
			final ContentMetadata contentMetadata = findMetadata(query, ch.id, id);
			return new StatementHandle(ch.id, id, contentMetadata.getSign());
		} catch (final AtsdException | GeneralSecurityException | IOException e) {
			if (log.isDebugEnabled())
				log.debug("[prepare]" + e.getMessage());
		}
		return null;
	}

	@Override
	public ExecuteResult execute(StatementHandle h, List parameterValues, long maxRowCount)
			throws NoSuchStatementException {
		if (log.isTraceEnabled()) {
			log.trace("[execute] maxRowCount: {} parameters: {} handle: {}", maxRowCount, parameterValues.size(),
					h.toString());
		}
		final IDataProvider provider = providerCache.get(h.id);
		assert provider != null;
		String query = new String(h.signature.sql);
		if (query.contains("?")) {
			final Iterator iterator = parameterValues.iterator();
			final StringBuilder sb = new StringBuilder();
			final String[] parts = query.split("\\?", -1);
			assert parts.length == parameterValues.size() + 1;
			if (parts.length != parameterValues.size() + 1) {
				throw new IndexOutOfBoundsException(
						String.format("Number of specified values [%d] is not match to number of occurences [%d]",
								parameterValues.size(), parts.length));
			}
			for (String part : parts) {
				sb.append(part);
				if (!iterator.hasNext())
					break;
				final TypedValue next = iterator.next();
				if (next.value instanceof Number)
					sb.append((Number) next.value);
				else if (next.value instanceof String)
					sb.append('\'').append((String) next.value).append('\'');
				else if (next.value instanceof java.sql.Date) {
					sb.append('\'').append(DATE_FORMATTER.get().format((java.sql.Date) next.value)).append('\'');
				} else if (next.value instanceof java.sql.Time) {
					sb.append('\'').append(TIME_FORMATTER.get().format((java.sql.Time) next.value)).append('\'');
				} else if (next.value instanceof Timestamp) {
					sb.append('\'').append(TIMESTAMP_FORMATTER.get().format((Timestamp) next.value)).append('\'');
				}
			}
			if (log.isDebugEnabled())
				log.debug("[execute] " + sb.toString());
			provider.getContentDescription().setQuery(sb.toString());
		}
		try {
			provider.fetchData(-1);
			final ContentMetadata contentMetadata = findMetadata(query, h.connectionId, h.id);
			return new ExecuteResult(contentMetadata.getList());
		} catch (final AtsdException | GeneralSecurityException | IOException e) {
			if (log.isDebugEnabled())
				log.debug("[execute] " + e.getMessage());
			throw new NoSuchStatementException(h);
		}
	}

	@Override
	public ExecuteResult prepareAndExecute(final StatementHandle h, String query, long maxRowCount,
			final PrepareCallback callback) throws NoSuchStatementException {
		try {
			lock.lockInterruptibly();
		} catch (InterruptedException e) {
			if (log.isDebugEnabled())
				log.debug("[prepareAndExecute] " + e.getMessage());
		}
		if (log.isTraceEnabled()) {
			log.trace("[prepareAndExecute] locked: {} maxRowCount: {} handle: {} query: {}", lock.getHoldCount(),
					maxRowCount, h.toString(), query);
		}
		try {
			final IDataProvider provider = initProvider(h.id, query);
			provider.fetchData(maxRowCount);
			final ContentMetadata contentMetadata = findMetadata(query, h.connectionId, h.id);
			synchronized (callback.getMonitor()) {
				// callback.clear();
				callback.assign(contentMetadata.getSign(), null, -1);
			}
			final ExecuteResult result = new ExecuteResult(contentMetadata.getList());
			callback.execute();
			return result;
		} catch (final AtsdException | IOException | SQLException | GeneralSecurityException e) {
			if (log.isDebugEnabled())
				log.debug("[prepareAndExecute] " + e.getMessage());
			throw new NoSuchStatementException(h);
		}
	}

	@Override
	public Frame fetch(final StatementHandle h, long loffset, int fetchMaxRowCount)
			throws NoSuchStatementException, MissingResultsException {
		final int offset = (int) loffset;
		if (log.isTraceEnabled()) {
			log.trace("[fetch] fetchMaxRowCount: {} offset: {}", fetchMaxRowCount, offset);
		}
		IDataProvider provider = providerCache.get(h.id);
		assert provider != null;
		final ContentDescription cd = provider.getContentDescription();
		final IStoreStrategy strategy = provider.getStrategy();
		try {
			if (offset == 0) {
				final String[] headers = strategy.openToRead();
				if (headers == null || headers.length == 0)
					throw new MissingResultsException(h);
				cd.setHeaders(headers);
			}
			final List subList = strategy.fetch(offset, fetchMaxRowCount);
			final List