Merge remote-tracking branch 'origin/develop' into feature/crash_gen

src/connector/jdbc/src/test/java/com/taosdata/jdbc/SubscribeTest.java

@@ -10,8 +10,6 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.Properties;
 
-import static org.junit.Assert.assertTrue;
-
 public class SubscribeTest extends BaseTest {
     Connection connection = null;
     Statement statement = null;

src/tsdb/src/tsdbRWHelper.c

@@ -1348,7 +1348,7 @@ static int tsdbLoadBlockDataImpl(SRWHelper *pHelper, SCompBlock *pCompBlock, SDa
   int dcol = 0;  // loop iter for SDataCols object
   while (dcol < pDataCols->numOfCols) {
     SDataCol *pDataCol = &(pDataCols->cols[dcol]);
-    if (ccol >= pCompData->numOfCols) {
+    if (dcol != 0 && ccol >= pCompData->numOfCols) {
       // Set current column as NULL and forward
       dataColSetNEleNull(pDataCol, pCompBlock->numOfRows, pDataCols->maxPoints);
       dcol++;

tests/examples/JDBC/JDBCDemo/pom.xml

@@ -9,21 +9,20 @@
     <version>1.0-SNAPSHOT</version>
     <packaging>jar</packaging>
     <build>
-        <pluginManagement>
+
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-plugins</artifactId>
                 <version>30</version>
             </plugin>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>
                 <version>3.0.0</version>
             </plugin>
-            </plugins>
-        </pluginManagement>
-        <plugins>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>
@@ -48,6 +47,7 @@
                     </execution>
                 </executions>
             </plugin>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>

tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java

+package com.taosdata.example;
+
+import com.taosdata.jdbc.TSDBDriver;
+
+import java.sql.*;
+import java.util.Properties;
+
+public class JDBCConnectorChecker {
+    private static String host;
+    private static String dbName = "test";
+    private static String tbName = "weather";
+    private Connection connection;
+
+
+    /**
+     * get connection
+     **/
+    private void init() {
+        try {
+            Class.forName("com.taosdata.jdbc.TSDBDriver");
+            Properties properties = new Properties();
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+            System.out.println("get connection starting...");
+            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
+            if (connection != null)
+                System.out.println("[ OK ] Connection established.");
+        } catch (ClassNotFoundException | SQLException e) {
+            throw new RuntimeException("connection failed: " + host);
+        }
+    }
+
+    /**
+     * create database
+     */
+    private void createDatabase() {
+        String sql = "create database if not exists " + dbName;
+        exuete(sql);
+    }
+
+    /**
+     * use database
+     */
+    private void useDatabase() {
+        String sql = "use " + dbName;
+        exuete(sql);
+    }
+
+    /**
+     * select
+     */
+    private void checkSelect() {
+        final String sql = "select * from test.weather";
+        executeQuery(sql);
+    }
+
+    private void executeQuery(String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            ResultSet resultSet = statement.executeQuery(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, true, (end - start));
+            printResult(resultSet);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void printResult(ResultSet resultSet) throws SQLException {
+        ResultSetMetaData metaData = resultSet.getMetaData();
+        while (resultSet.next()) {
+            for (int i = 1; i <= metaData.getColumnCount(); i++) {
+                String columnLabel = metaData.getColumnLabel(i);
+                String value = resultSet.getString(i);
+                System.out.printf("%s: %s\t", columnLabel, value);
+            }
+            System.out.println();
+        }
+    }
+
+    private String formatString(String str) {
+        StringBuilder sb = new StringBuilder();
+        int blankCnt = (26 - str.length()) / 2;
+        for (int j = 0; j < blankCnt; j++)
+            sb.append(" ");
+        sb.append(str);
+        for (int j = 0; j < blankCnt; j++)
+            sb.append(" ");
+        sb.append("|");
+        return sb.toString();
+    }
+
+
+    /**
+     * insert
+     */
+    private void checkInsert() {
+        final String sql = "insert into test.weather (ts, temperature, humidity) values(now, 20.5, 34)";
+        exuete(sql);
+    }
+
+    /**
+     * create table
+     */
+    private void createTable() {
+        final String sql = "create table if not exists " + dbName + "." + tbName + " (ts timestamp, temperature float, humidity int)";
+        exuete(sql);
+    }
+
+    private final void printSql(String sql, boolean succeed, long cost) {
+        System.out.println("[ " + (succeed ? "OK" : "ERROR!") + " ] time cost: " + cost + " ms, execute statement ====> " + sql);
+    }
+
+    private final void exuete(String sql) {
+        try (Statement statement = connection.createStatement()) {
+            long start = System.currentTimeMillis();
+            boolean execute = statement.execute(sql);
+            long end = System.currentTimeMillis();
+            printSql(sql, execute, (end - start));
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void close() {
+        try {
+            if (connection != null) {
+                this.connection.close();
+                System.out.println("connection closed.");
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void checkDropTable() {
+        final String sql = "drop table if exists " + dbName + "." + tbName + "";
+        exuete(sql);
+    }
+
+    public static void main(String[] args) {
+        for (int i = 0; i < args.length; i++) {
+            if ("-host".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                host = args[++i];
+            }
+            if ("-db".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                dbName = args[++i];
+            }
+            if ("-t".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                tbName = args[++i];
+            }
+        }
+
+        if (host == null) {
+            System.out.println("Usage: java -jar JDBCConnectorChecker.jar -host <hostname>");
+            return;
+        }
+
+        JDBCConnectorChecker checker = new JDBCConnectorChecker();
+        checker.init();
+        checker.createDatabase();
+        checker.useDatabase();
+        checker.checkDropTable();
+        checker.createTable();
+        checker.checkInsert();
+        checker.checkSelect();
+        checker.checkDropTable();
+        checker.close();
+    }
+
+
+}

tests/pytest/fulltest.sh

@@ -185,6 +185,7 @@ python3 ./test.py -f functions/function_stddev.py
 python3 ./test.py -f functions/function_sum.py
 python3 ./test.py -f functions/function_top.py
 #python3 ./test.py -f functions/function_twa.py
+python3 queryCount.py
 
 # tools
 python3 test.py -f tools/taosdemo.py

tests/pytest/query/queryNormal.py

@@ -42,6 +42,8 @@ class TDTestCase:
         # join 3 tables -- bug exists
         tdSql.error("select stb_t.ts, stb_t.dscrption, stb_t.temperature, stb_p.id, stb_p.dscrption, stb_p.pressure,stb_v.velocity from stb_p, stb_t, stb_v where stb_p.ts=stb_t.ts and stb_p.ts=stb_v.ts and stb_p.id = stb_t.id")
 
+        tdSql.error("select * from stb1 whern c1 > 'test' limit 100")
+
         # query show stable
         tdSql.query("show stables")
         tdSql.checkRows(1)

tests/pytest/query/queryNullValueTest.py

@@ -42,6 +42,9 @@ class TDTestCase:
         tdSql.prepare()
         
         for i in range(len(self.types)):
+            tdSql.execute("drop table if exists t0")
+            tdSql.execute("drop table if exists t1")
+            
             print("======== checking type %s ==========" % self.types[i])
             tdSql.execute("create table t0 (ts timestamp, col %s)" % self.types[i])
             tdSql.execute("insert into t0 values (%d, NULL)" % (self.ts))

tests/pytest/queryCount.py

+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import sys
+import taos
+import threading
+from util.log import *
+from util.cases import *
+from util.sql import *
+from util.dnodes import *
+
+
+class QueryCountMultiThread:
+    def initConnection(self):        
+        self.records = 10000000
+        self.numOfTherads = 50
+        self.ts = 1537146000000
+        self.host = "127.0.0.1"
+        self.user = "root"
+        self.password = "taosdata"
+        self.config = "/home/xp/git/TDengine/sim/dnode1/cfg"
+        self.conn = taos.connect(
+            self.host,
+            self.user,
+            self.password,
+            self.config)
+
+    def insertData(self, threadID):
+        cursor = self.conn.cursor()
+        print("Thread %d: starting" % threadID)
+        base = 200000 * threadID
+        for i in range(200):                        
+            query = "insert into tb values"
+            for j in range(1000):
+                query += "(%d, %d, 'test')" % (self.ts + base + i * 1000 + j, base + i * 1000 + j)                        
+            cursor.execute(query)            
+        cursor.close()
+        print("Thread %d: finishing" % threadID)
+
+    def run(self):
+        tdDnodes.init("")
+        tdDnodes.setTestCluster(False)
+        tdDnodes.setValgrind(False)
+
+        tdDnodes.stopAll()
+        tdDnodes.deploy(1)
+        tdDnodes.start(1)
+        
+        cursor = self.conn.cursor()
+        cursor.execute("drop database if exists db")
+        cursor.execute("create database db")
+        cursor.execute("use db")
+        cursor.execute("create table tb (ts timestamp, id int, name nchar(30))")
+        cursor.close()
+
+        threads = []
+        for i in range(50):
+            thread = threading.Thread(target=self.insertData, args=(i,))
+            threads.append(thread)
+            thread.start()            
+        
+        for i in range(50):
+            threads[i].join()
+
+        cursor = self.conn.cursor()
+        cursor.execute("use db")
+        sql = "select count(*) from tb"
+        cursor.execute(sql)
+        data = cursor.fetchall()
+
+        if(data[0][0] == 10000000):
+            tdLog.info("sql:%s, row:%d col:%d data:%d == expect:%d" % (sql, 0, 0, data[0][0], 10000000))
+        else:            
+            tdLog.exit("queryCount.py failed: sql:%s failed, row:%d col:%d data:%d != expect:%d" % (sql, 0, 0, data[0][0], 10000000))        
+
+        cursor.close()
+        self.conn.close()
+
+q = QueryCountMultiThread()
+q.initConnection()
+q.run()
\ No newline at end of file