• Home
• com.taosdata.jdbc
• taos-jdbcdriver
• 3.3.3
• source code
• TSWSPreparedStatement.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.taosdata.jdbc.ws.TSWSPreparedStatement Maven / Gradle / Ivy

package com.taosdata.jdbc.ws;

import com.taosdata.jdbc.*;
import com.taosdata.jdbc.common.ColumnInfo;
import com.taosdata.jdbc.common.SerializeBlock;
import com.taosdata.jdbc.enums.BindType;
import com.taosdata.jdbc.enums.DataType;
import com.taosdata.jdbc.enums.TimestampPrecision;
import com.taosdata.jdbc.rs.ConnectionParam;
import com.taosdata.jdbc.utils.ReqId;
import com.taosdata.jdbc.utils.Utils;
import com.taosdata.jdbc.ws.entity.Action;
import com.taosdata.jdbc.ws.entity.Code;
import com.taosdata.jdbc.ws.entity.Request;
import com.taosdata.jdbc.ws.entity.Response;
import com.taosdata.jdbc.ws.stmt.entity.ExecResp;
import com.taosdata.jdbc.ws.stmt.entity.GetColFieldsResp;
import com.taosdata.jdbc.ws.stmt.entity.RequestFactory;
import com.taosdata.jdbc.ws.stmt.entity.StmtResp;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.sql.Date;
import java.sql.*;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import static com.taosdata.jdbc.TSDBConstants.*;
import static com.taosdata.jdbc.utils.SqlSyntaxValidator.getDatabaseName;
import static com.taosdata.jdbc.utils.SqlSyntaxValidator.isUseSql;

public class TSWSPreparedStatement extends WSStatement implements PreparedStatement {
   public static final Pattern INSERT_PATTERN = Pattern.compile(
             "insert\\s+into\\s+([.\\w]+|\\?)\\s+(using\\s+([.\\w]+)(\\s*\\(.*\\)\\s*|\\s+)tags\\s*\\(.*\\))?\\s*(\\(.*\\))?\\s*values\\s*\\(.*\\)"
   );
    private final ConnectionParam param;
    private long reqId;
    private long stmtId;
    private final String rawSql;

    private int queryTimeout = 0;
    private int precision = TimestampPrecision.MS;

    private String insertDbName;
    static private Map precisionHashMap = new ConcurrentHashMap();
    private final Map column = new HashMap<>();

    private final Map tag = new HashMap<>();
    private final List data = new ArrayList<>();

    private final PriorityQueue queue = new PriorityQueue<>();

    public TSWSPreparedStatement(Transport transport, ConnectionParam param, String database, AbstractConnection connection, String sql, Long instanceId) throws SQLException {
        super(transport, database, connection, instanceId);
        this.rawSql = sql;
        this.param = param;
        this.insertDbName = database;
        if (!sql.contains("?"))
            return;

        String useDb = null;
        Matcher matcher = INSERT_PATTERN.matcher(sql);
        if (matcher.find()) {
            if (matcher.group(1).equals("?") && matcher.group(3) != null) {
                String usingGroup = matcher.group(3);
                if (usingGroup.contains(".")) {
                    String[] split = usingGroup.split("\\.");
                    useDb = split[0];
                }
            } else {
                String usingGroup = matcher.group(1);
                if (usingGroup.contains(".")) {
                    String[] split = usingGroup.split("\\.");
                    useDb = split[0];
                }
            }

            if (useDb == null && database != null) {
                useDb = database;
            }
            if (useDb != null) {
                insertDbName = useDb;
                Integer precisionObj = precisionHashMap.get(useDb);
                if (precisionObj != null){
                    precision = precisionObj;
                } else {
                    updatePrecision(useDb);
                }
            }
        }


        reqId = ReqId.getReqID();
        Request request = RequestFactory.generateInit(reqId);
        StmtResp resp = (StmtResp) transport.send(request);
        if (Code.SUCCESS.getCode() != resp.getCode()) {
            throw new SQLException("(0x" + Integer.toHexString(resp.getCode()) + "):" + resp.getMessage());
        }
        stmtId = resp.getStmtId();
        Request prepare = RequestFactory.generatePrepare(stmtId, reqId, sql);
        StmtResp prepareResp = (StmtResp) transport.send(prepare);
        if (Code.SUCCESS.getCode() != prepareResp.getCode()) {
            throw new SQLException("(0x" + Integer.toHexString(prepareResp.getCode()) + "):" + prepareResp.getMessage());
        }
    }

    private void updatePrecision(String database) throws SQLException{
        try (ResultSet resultSet = this.executeQuery("select `precision` from information_schema.ins_databases where name = '" + database + "'")) {
            while (resultSet.next()) {
                String tmp = resultSet.getString(1);
                precision = TimestampPrecision.getPrecision(tmp);
                precisionHashMap.put(database, precision);
            }
        }
    }
    @Override
    public int getQueryTimeout() throws SQLException {
        return queryTimeout;
    }

    @Override
    public void setQueryTimeout(int seconds) throws SQLException {
        if (isClosed())
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
        if (seconds < 0)
            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);

        this.queryTimeout = seconds;
        transport.setTimeout(seconds * 1000L);
    }

    private void checkUseStatement(String sql) throws SQLException {
        if (sql == null || sql.isEmpty()) {
            throw new SQLException("sql is empty");
        }

        if (isUseSql(sql)) {
            String database = getDatabaseName(sql);
            if (null != database) {
                WSConnection.reInitTransport(transport, param, database);

                try (ResultSet resultSet = this.executeQuery("select `precision` from information_schema.ins_databases where name = '" + database + "'")) {
                    while (resultSet.next()) {
                        String tmp = resultSet.getString(1);
                        precision = TimestampPrecision.getPrecision(tmp);
                    }
                }

                reqId = ReqId.getReqID();
                Request request = RequestFactory.generateInit(reqId);
                StmtResp resp = (StmtResp) transport.send(request);
                if (Code.SUCCESS.getCode() != resp.getCode()) {
                    throw new SQLException("(0x" + Integer.toHexString(resp.getCode()) + "):" + resp.getMessage());
                }
                stmtId = resp.getStmtId();
                Request prepare = RequestFactory.generatePrepare(stmtId, reqId, rawSql);
                StmtResp prepareResp = (StmtResp) transport.send(prepare);
                if (Code.SUCCESS.getCode() != prepareResp.getCode()) {
                    throw new SQLException("(0x" + Integer.toHexString(prepareResp.getCode()) + "):" + prepareResp.getMessage());
                }
            }
        }
    }

    @Override
    public boolean execute(String sql, Long reqId) throws SQLException {
        checkUseStatement(sql);
        return super.execute(sql, reqId);
    }

    @Override
    public ResultSet executeQuery() throws SQLException {
        List