xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

fix python source code for pep8 standard.

This commit is contained in:
Shuduo Sang 2020-04-27 15:23:15 +08:00
parent fd76b5f71d
commit 2777a2f0c9
68 changed files with 3808 additions and 3590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
tests/pytest/import_merge/importBlock1H.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,53 +18,55 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data before") tdLog.info("import 38 sequential data")
startTime = self.startTime - 1 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) sqlcmd = ['import into tb1 values']
for rid in range(1, 39):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(39)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(39)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock1HO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 10 data before with overlap") tdLog.info("import 38 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 10 data before with overlap")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(43)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(43)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

110
tests/pytest/import_merge/importBlock1HPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,60 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
for rid in range(15,43):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 20 data before with partly overlap") tdLog.info("import 38 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,21): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) for rid in range(15, 43):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 20 data before with partly overlap")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(47)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(47)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock1S.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 50 data covering existing data") tdLog.info("import 38 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,51): for rid in range(1, 39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 50 data covering existing data")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 51):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(50)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(50)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock1Sub.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 10 data totally repetitive") tdLog.info("import 38 sequential data")
startTime = self.startTime startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 10 data totally repetitive")
startTime = self.startTime
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

100
tests/pytest/import_merge/importBlock1T.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,53 +18,55 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data after") tdLog.info("import 38 sequential data")
startTime = self.startTime + 38 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+1, rid)) sqlcmd = ['import into tb1 values']
for rid in range(1, 39):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 1 data after")
startTime = self.startTime + 38
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(39)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(39)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock1TO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 10 data later with overlap") tdLog.info("import 38 sequential data")
startTime = self.startTime + 30 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 10 data later with overlap")
startTime = self.startTime + 30
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(40)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(40)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

110
tests/pytest/import_merge/importBlock1TPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,60 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 38 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,31):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
for rid in range(35,43):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 30 data later with partly overlap") tdLog.info("import 38 sequential data")
startTime = self.startTime + 25 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,31): for rid in range(1, 31):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) for rid in range(35, 43):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(38)
tdLog.info("================= step4")
tdLog.info("import 30 data later with partly overlap")
startTime = self.startTime + 25
sqlcmd = ['import into tb1 values']
for rid in range(1, 31):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(55)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(55)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

100
tests/pytest/import_merge/importBlock2H.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,53 +18,55 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data before") tdLog.info("import 76 sequential data")
startTime = self.startTime - 1 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) sqlcmd = ['import into tb1 values']
for rid in range(1, 77):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(77)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(77)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock2HO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 10 data before with overlap") tdLog.info("import 76 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 10 data before with overlap")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(81)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(81)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

110
tests/pytest/import_merge/importBlock2HPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,60 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
for rid in range(15,81):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 20 data before with partly overlap") tdLog.info("import 76 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,21): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) for rid in range(15, 81):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 20 data before with partly overlap")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(85)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(85)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock2S.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 90 data covering existing data") tdLog.info("import 76 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,91): for rid in range(1, 77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 90 data covering existing data")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 91):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(90)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(90)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock2Sub.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 10 data totally repetitive") tdLog.info("import 76 sequential data")
startTime = self.startTime + 10 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 10 data totally repetitive")
startTime = self.startTime + 10
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

100
tests/pytest/import_merge/importBlock2T.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,53 +18,55 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data after") tdLog.info("import 76 sequential data")
startTime = self.startTime + 76 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+1, rid)) sqlcmd = ['import into tb1 values']
for rid in range(1, 77):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 1 data after")
startTime = self.startTime + 76
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(77)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(77)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importBlock2TO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,58 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 10 data later with overlap") tdLog.info("import 76 sequential data")
startTime = self.startTime + 70 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 77):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 10 data later with overlap")
startTime = self.startTime + 70
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(80)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(80)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

110
tests/pytest/import_merge/importBlock2TPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,60 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,61):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
for rid in range(65,81):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 30 data later with partly overlap") tdLog.info("import 76 sequential data")
startTime = self.startTime + 55 startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,31): for rid in range(1, 61):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) for rid in range(65, 81):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import 30 data later with partly overlap")
startTime = self.startTime + 55
sqlcmd = ['import into tb1 values']
for rid in range(1, 31):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(85)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(85)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

112
tests/pytest/import_merge/importBlockbetween.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,59 +18,61 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db cache 512') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db cache 512')
tdLog.info("one block can import 38 records") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 76 sequential data with gap between 2 blocks") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("one block can import 38 records")
for rid in range(1,39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
for rid in range(40,78):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import data into the gap between 2 blocks") tdLog.info("import 76 sequential data with gap between 2 blocks")
startTime = self.startTime startTime = self.startTime
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(39,40): for rid in range(1, 39):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
for rid in range(40, 78):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(76)
tdLog.info("================= step4")
tdLog.info("import data into the gap between 2 blocks")
startTime = self.startTime
sqlcmd = ['import into tb1 values']
for rid in range(39, 40):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(77)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(77)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

126
tests/pytest/import_merge/importCacheFileH.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,69 +18,71 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 10 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data again") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(10)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(20) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 1 data before") tdLog.info("import 10 data again")
startTime = self.startTime - 1 startTime = self.startTime + 10
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step7")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(21)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(21)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

132
tests/pytest/import_merge/importCacheFileHO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,72 +18,74 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 10 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data again") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(10)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(20) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 10 data before with overlap") tdLog.info("import 10 data again")
startTime = self.startTime - 5 startTime = self.startTime + 10
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step7")
tdLog.info("import 10 data before with overlap")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(25)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(25)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

138
tests/pytest/import_merge/importCacheFileHPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,74 +18,78 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 9 sequential data with gap") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
if (rid == 5): continue
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(9)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 9 sequential data with gap")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
if (rid == 5):
continue
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 9 data again with gap") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(9)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
if (rid == 5): continue
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(18) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 20 data before with partly overlap") tdLog.info("import 9 data again with gap")
startTime = self.startTime - 3 startTime = self.startTime + 10
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,21): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) if (rid == 5):
tdSql.execute(" ".join(sqlcmd)) continue
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(18)
tdLog.info("================= step7")
tdLog.info("import 20 data before with partly overlap")
startTime = self.startTime - 3
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(23)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(23)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

132
tests/pytest/import_merge/importCacheFileS.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,72 +18,74 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 10 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data again") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(10)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(20) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 30 data covering existing data") tdLog.info("import 10 data again")
startTime = self.startTime - 5 startTime = self.startTime + 10
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,31): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step7")
tdLog.info("import 30 data covering existing data")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 31):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(30)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(30)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

132
tests/pytest/import_merge/importCacheFileSub.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,72 +18,74 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 10 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data again") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(10)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(20) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 10 data totally repetitive") tdLog.info("import 10 data again")
startTime = self.startTime + 5 startTime = self.startTime + 10
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step7")
tdLog.info("import 10 data totally repetitive")
startTime = self.startTime + 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

126
tests/pytest/import_merge/importCacheFileT.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,69 +18,71 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 10 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data again") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(10)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(20) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 1 data later") tdLog.info("import 10 data again")
startTime = self.startTime + 20 startTime = self.startTime + 10
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+1, rid)) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step7")
tdLog.info("import 1 data later")
startTime = self.startTime + 20
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, rid))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(21)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(21)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

132
tests/pytest/import_merge/importCacheFileTO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,72 +18,74 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 10 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data again") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(10)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(20) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 10 data later with overlap") tdLog.info("import 10 data again")
startTime = self.startTime + 15 startTime = self.startTime + 10
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,11): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd)) tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step7")
tdLog.info("import 10 data later with overlap")
startTime = self.startTime + 15
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(25)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(25)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

138
tests/pytest/import_merge/importCacheFileTPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,74 +18,78 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 9 sequential data with gap") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
if (rid == 7): continue
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(9)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 9 sequential data with gap")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
if (rid == 7):
continue
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 9 data again with gap") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(9)
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
if (rid == 7): continue
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step4")
tdSql.query('select * from tb1') tdDnodes.stop(1)
tdSql.checkRows(18) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step7") tdLog.info("================= step5")
tdLog.info("import 20 data later with partly overlap") tdLog.info("import 9 data again with gap")
startTime = self.startTime + 5 startTime = self.startTime + 10
sqlcmd = ['import into tb1 values'] sqlcmd = ['import into tb1 values']
for rid in range(1,21): for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) if (rid == 7):
tdSql.execute(" ".join(sqlcmd)) continue
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(18)
tdLog.info("================= step7")
tdLog.info("import 20 data later with partly overlap")
startTime = self.startTime + 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(25)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step8")
tdSql.query('select * from tb1')
tdSql.checkRows(25)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

141
tests/pytest/import_merge/importDataH2.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,74 +18,77 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import %d sequential data" %(self.rows/2)) tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,self.rows/2+1): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(self.rows/2)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import %d sequential data" % (self.rows / 2))
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, self.rows / 2 + 1):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 1 data before") tdSql.query('select * from tb1')
startTime = self.startTime - 1 tdSql.checkRows(self.rows / 2)
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime + 1, 1))
tdLog.info("================= step4")
tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
tdLog.info("================= step7")
tdSql.execute('reset query cache')
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rows / 2 + 1)
tdLog.info("================= step8")
tdLog.info("import 10 data in batch before")
startTime = self.startTime
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime - rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step9")
tdSql.execute('reset query cache')
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rows / 2 + 11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step7")
tdSql.execute('reset query cache')
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rows/2 + 1)
tdLog.info("================= step8")
tdLog.info("import 10 data in batch before")
startTime = self.startTime
sqlcmd = ['import into tb1 values']
for rid in range(1,11):
sqlcmd.append('(%ld, %d)' %(startTime - rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step9")
tdSql.execute('reset query cache')
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rows/2 + 11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

120
tests/pytest/import_merge/importDataHO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,63 +18,67 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
self.rowsPerTable = 20
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
self.rowsPerTable = 20
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import %d sequential data" %self.rowsPerTable) tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,self.rowsPerTable+1): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select count(*) from tb1')
tdSql.checkData(0, 0, self.rowsPerTable)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import %d sequential data" % self.rowsPerTable)
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, self.rowsPerTable + 1):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 6 data before with overlap") tdSql.query('select count(*) from tb1')
startTime = self.startTime - 3 tdSql.checkData(0, 0, self.rowsPerTable)
sqlcmd = ['import into tb1 values']
for rid in range(1,7): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 6 data before with overlap")
startTime = self.startTime - 3
sqlcmd = ['import into tb1 values']
for rid in range(1, 7):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rowsPerTable + 3)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rowsPerTable + 3)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

120
tests/pytest/import_merge/importDataHO2.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,63 +18,67 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
self.rowsPerTable = 100
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
self.rowsPerTable = 100
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import %d sequential data" %self.rowsPerTable) tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,self.rowsPerTable+1): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select count(*) from tb1')
tdSql.checkData(0, 0, self.rowsPerTable)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import %d sequential data" % self.rowsPerTable)
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, self.rowsPerTable + 1):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 6 data before with overlap") tdSql.query('select count(*) from tb1')
startTime = self.startTime - 3 tdSql.checkData(0, 0, self.rowsPerTable)
sqlcmd = ['import into tb1 values']
for rid in range(6, 0, -1): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 6 data before with overlap")
startTime = self.startTime - 3
sqlcmd = ['import into tb1 values']
for rid in range(6, 0, -1):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rowsPerTable + 3)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rowsPerTable+3)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

124
tests/pytest/import_merge/importDataHPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,65 +18,69 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
self.rowsPerTable = 20
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
self.rowsPerTable = 20
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import %d sequential data" %self.rowsPerTable) tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,10): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
for rid in range(14,self.rowsPerTable+5):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select count(*) from tb1')
tdSql.checkData(0, 0, self.rowsPerTable)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import %d sequential data" % self.rowsPerTable)
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 10):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
for rid in range(14, self.rowsPerTable + 5):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 20 data before with partly overlap") tdSql.query('select count(*) from tb1')
startTime = self.startTime - 4 tdSql.checkData(0, 0, self.rowsPerTable)
sqlcmd = ['import into tb1 values']
for rid in range(1,21): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 20 data before with partly overlap")
startTime = self.startTime - 4
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(self.rowsPerTable + 8)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(self.rowsPerTable+8)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

112
tests/pytest/import_merge/importDataLastH.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,59 +18,63 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,206): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 206):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 1 data before") tdSql.query('select * from tb1')
startTime = self.startTime - 1 tdSql.checkRows(205)
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime + 1, 1))
tdLog.info("================= step4")
tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(206)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(206)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

118
tests/pytest/import_merge/importDataLastHO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,62 +18,66 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,206): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 206):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 5 data before with overlap") tdSql.query('select * from tb1')
startTime = self.startTime - 2 tdSql.checkRows(205)
sqlcmd = ['import into tb1 values']
for rid in range(1,6): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 5 data before with overlap")
startTime = self.startTime - 2
sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(207)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(207)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

122
tests/pytest/import_merge/importDataLastHPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,64 +18,68 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,11): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
for rid in range(14,209):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
for rid in range(14, 209):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 20 data before with partly overlap") tdSql.query('select * from tb1')
startTime = self.startTime - 2 tdSql.checkRows(205)
sqlcmd = ['import into tb1 values']
for rid in range(1,21): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 20 data before with partly overlap")
startTime = self.startTime - 2
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(210)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(210)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

118
tests/pytest/import_merge/importDataLastS.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,62 +18,66 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,206): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 206):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 250 data covering the existing data") tdSql.query('select * from tb1')
startTime = self.startTime - 15 tdSql.checkRows(205)
sqlcmd = ['import into tb1 values']
for rid in range(1,251): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 250 data covering the existing data")
startTime = self.startTime - 15
sqlcmd = ['import into tb1 values']
for rid in range(1, 251):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(250)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(250)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

118
tests/pytest/import_merge/importDataLastSub.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,62 +18,66 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,206): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 206):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data totally repetitive") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(205)
sqlcmd = ['import into tb1 values']
for rid in range(1,11): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 10 data totally repetitive")
startTime = self.startTime + 10
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importDataLastT.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,55 +18,59 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,206): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 206):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 1 data later") tdSql.query('select * from tb1')
startTime = self.startTime + 205 tdSql.checkRows(205)
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime + 1, 1))
tdLog.info("================= step4")
tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 1 data later")
startTime = self.startTime + 205
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(206)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(206)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

112
tests/pytest/import_merge/importDataLastTO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,62 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,206): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 206):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 5 data later with overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 203 tdSql.checkRows(205)
sqlcmd = ['import into tb1 values']
for rid in range(1,6): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 5 data later with overlap")
startTime = self.startTime + 203
sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(208)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(208)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

116
tests/pytest/import_merge/importDataLastTPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,60 +18,64 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than %d rows less than %d rows will go to data and last file" %(self.rows, 10+self.rows)) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 205 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,196): "More than %d rows less than %d rows will go to data and last file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) (self.rows, 10 + self.rows))
for rid in range(200,210):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(205)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 205 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 196):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
for rid in range(200, 210):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 20 data later with partly overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 192 tdSql.checkRows(205)
sqlcmd = ['import into tb1 values']
for rid in range(1,21): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 20 data later with partly overlap")
startTime = self.startTime + 192
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(212)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(212)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

112
tests/pytest/import_merge/importDataS.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,62 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 20 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,21): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 20 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 30 data covering the existing data") tdSql.query('select * from tb1')
startTime = self.startTime - 5 tdSql.checkRows(20)
sqlcmd = ['import into tb1 values']
for rid in range(1,31): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 30 data covering the existing data")
startTime = self.startTime - 5
sqlcmd = ['import into tb1 values']
for rid in range(1, 31):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(30)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(30)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

120
tests/pytest/import_merge/importDataSub.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,63 +18,67 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import %d sequential data" %(self.rows/2)) tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,self.rows/2+1): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(self.rows/2)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import %d sequential data" % (self.rows / 2))
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, self.rows / 2 + 1):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 10 data totally repetitive") tdSql.query('select * from tb1')
startTime = self.startTime + 10 tdSql.checkRows(self.rows / 2)
sqlcmd = ['import into tb1 values']
for rid in range(1,11): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 10 data totally repetitive")
startTime = self.startTime + 10
sqlcmd = ['import into tb1 values']
for rid in range(1, 11):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step9")
tdSql.execute('reset query cache')
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rows / 2)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step9")
tdSql.execute('reset query cache')
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(self.rows/2)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

106
tests/pytest/import_merge/importDataT.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,55 +18,59 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 20 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,21): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 20 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 1 data later") tdSql.query('select * from tb1')
startTime = self.startTime + 20 tdSql.checkRows(20)
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime + 1, 1))
tdLog.info("================= step4")
tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 1 data later")
startTime = self.startTime + 20
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(21)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(21)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

112
tests/pytest/import_merge/importDataTO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,62 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 20 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,21): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 20 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 6 data later with overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 18 tdSql.checkRows(20)
sqlcmd = ['import into tb1 values']
for rid in range(1,7): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 6 data later with overlap")
startTime = self.startTime + 18
sqlcmd = ['import into tb1 values']
for rid in range(1, 7):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(24)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(24)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

118
tests/pytest/import_merge/importDataTPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,61 +18,65 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("More than 10 rows less than %d rows will go to data file" %self.rows) tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 20 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(1,18): "More than 10 rows less than %d rows will go to data file" %
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) self.rows)
for rid in range(22,25):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 20 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
tdLog.sleep(5) for rid in range(1, 18):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
for rid in range(22, 25):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 20 data later with partly overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 15 tdSql.checkRows(20)
sqlcmd = ['import into tb1 values']
for rid in range(1,21): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.sleep(5)
tdLog.info("================= step5")
tdLog.info("import 20 data later with partly overlap")
startTime = self.startTime + 15
sqlcmd = ['import into tb1 values']
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(35)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(35)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

96
tests/pytest/import_merge/importHORestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,49 +18,55 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdSql.prepare() def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdLog.info("================= step1") tdSql.prepare()
tdLog.info("create 1 table")
tdSql.execute('create table tb1 (ts timestamp, i int)')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 5 data before with overlap") tdLog.info("import 10 sequential data")
startTime = self.startTime - 2 startTime = self.startTime
for rid in range(1,11): for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid)) tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5") tdLog.info("================= step3")
tdDnodes.forcestop(1) tdSql.query('select * from tb1')
tdDnodes.start(1) tdSql.checkRows(10)
tdLog.sleep(10)
tdLog.info("================= step4")
tdLog.info("import 5 data before with overlap")
startTime = self.startTime - 2
for rid in range(1, 11):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

104
tests/pytest/import_merge/importHPORestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,52 +18,60 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdSql.prepare() def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdLog.info("================= step1") tdSql.prepare()
tdLog.info("create 1 table")
tdSql.execute('create table tb1 (ts timestamp, i int)')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 8 sequential data with gap") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,4):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
for rid in range(6,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(8)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 8 data before with partly overlap") tdLog.info("import 8 sequential data with gap")
startTime = self.startTime - 2 startTime = self.startTime
for rid in range(1, 9): for rid in range(1, 4):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid)) tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
for rid in range(6, 11):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
startTime += 1
tdLog.info("================= step5") tdLog.info("================= step3")
tdDnodes.forcestop(1) tdSql.query('select * from tb1')
tdDnodes.start(1) tdSql.checkRows(8)
tdLog.sleep(10)
tdLog.info("================= step4")
tdLog.info("import 8 data before with partly overlap")
startTime = self.startTime - 2
for rid in range(1, 9):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

92
tests/pytest/import_merge/importHRestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,48 +18,52 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdSql.prepare() def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdLog.info("================= step1") tdSql.prepare()
tdLog.info("create 1 table")
tdSql.execute('create table tb1 (ts timestamp, i int)')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data before") tdLog.info("import 10 sequential data")
startTime = self.startTime - 1 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) for rid in range(1, 11):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5") tdLog.info("================= step3")
tdDnodes.forcestop(1) tdSql.query('select * from tb1')
tdDnodes.start(1) tdSql.checkRows(10)
tdLog.sleep(10)
tdLog.info("================= step4")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

96
tests/pytest/import_merge/importHead.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,51 +18,53 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data before") tdLog.info("import 10 sequential data")
startTime = self.startTime - 1 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

88
tests/pytest/import_merge/importHeadOverlap.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,46 +18,48 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdSql.prepare() def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdLog.info("================= step1") tdSql.prepare()
tdLog.info("create 1 table")
tdSql.execute('create table tb1 (ts timestamp, speed int)')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 5 data before with overlap") tdLog.info("import 10 sequential data")
startTime = self.startTime - 2 startTime = self.startTime
for rid in range(1,11): for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1 startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4")
tdLog.info("import 5 data before with overlap")
startTime = self.startTime - 2
for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

96
tests/pytest/import_merge/importHeadPartOverlap.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,50 +18,52 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdSql.prepare() def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdLog.info("================= step1") tdSql.prepare()
tdLog.info("create 1 table")
tdSql.execute('create table tb1 (ts timestamp, i int)')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 8 sequential data with gap") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,4):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid))
startTime += 1
startTime += 2
for rid in range(6,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(8)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 8 data before with partly overlap") tdLog.info("import 8 sequential data with gap")
startTime = self.startTime - 2 startTime = self.startTime
for rid in range(1, 9): for rid in range(1, 4):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1 startTime += 1
startTime += 2
for rid in range(6, 11):
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(8)
tdLog.info("================= step4")
tdLog.info("import 8 data before with partly overlap")
startTime = self.startTime - 2
for rid in range(1, 9):
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(12)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

104
tests/pytest/import_merge/importLastH.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,55 +18,57 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 5 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,6):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 5 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 1 data before") tdSql.query('select * from tb1')
startTime = self.startTime - 1 tdSql.checkRows(5)
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime + 1, 1))
tdLog.info("================= step4")
tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 1 data before")
startTime = self.startTime - 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(6)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(6)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

110
tests/pytest/import_merge/importLastHO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,60 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 5 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,6):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 5 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 4 data before with overlap") tdSql.query('select * from tb1')
startTime = self.startTime - 2 tdSql.checkRows(5)
sqlcmd = ['import into tb1 values']
for rid in range(1,5): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 4 data before with overlap")
startTime = self.startTime - 2
sqlcmd = ['import into tb1 values']
for rid in range(1, 5):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(7)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(7)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

114
tests/pytest/import_merge/importLastHPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,60 +18,62 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 6 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,4):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
for rid in range(6,9):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(6)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 6 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 4):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
for rid in range(6, 9):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 8 data before with partly overlap") tdSql.query('select * from tb1')
startTime = self.startTime - 2 tdSql.checkRows(6)
sqlcmd = ['import into tb1 values']
for rid in range(1,9): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 8 data before with partly overlap")
startTime = self.startTime - 2
sqlcmd = ['import into tb1 values']
for rid in range(1, 9):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

108
tests/pytest/import_merge/importLastS.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,57 +18,59 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 5 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,6):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 5 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 20 data covering existing data") tdSql.query('select * from tb1')
startTime = self.startTime - 10 tdSql.checkRows(5)
for rid in range(1,21):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdLog.info("================= step4")
tdSql.execute(" ".join(sqlcmd)) tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 20 data covering existing data")
startTime = self.startTime - 10
for rid in range(1, 21):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

110
tests/pytest/import_merge/importLastSub.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,60 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') def run(self):
tdSql.execute('drop database if exists db') self.ntables = 1
tdSql.execute('create database db rows %d' %self.rows) self.startTime = 1520000010000
tdSql.execute('use db') self.rows = 200
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 5 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,6):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 5 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 3 data totally repetitive") tdSql.query('select * from tb1')
startTime = self.startTime + 1 tdSql.checkRows(5)
sqlcmd = ['import into tb1 values']
for rid in range(1,4): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 3 data totally repetitive")
startTime = self.startTime + 1
sqlcmd = ['import into tb1 values']
for rid in range(1, 4):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

110
tests/pytest/import_merge/importLastT.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,59 +18,61 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 5 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,6):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 5 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 1 data later") tdSql.query('select * from tb1')
startTime = self.startTime + 5 tdSql.checkRows(5)
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime + 1, 1))
tdLog.info("================= step4")
tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 1 data later")
startTime = self.startTime + 5
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime + 1, 1))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(6)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(6)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

116
tests/pytest/import_merge/importLastTO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,62 +18,64 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 5 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,6):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(5)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 5 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 6):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 4 data later with overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 3 tdSql.checkRows(5)
sqlcmd = ['import into tb1 values']
for rid in range(1,5): tdLog.info("================= step4")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdDnodes.stop(1)
tdSql.execute(" ".join(sqlcmd)) tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 4 data later with overlap")
startTime = self.startTime + 3
sqlcmd = ['import into tb1 values']
for rid in range(1, 5):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(7)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(7)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

118
tests/pytest/import_merge/importLastTPO.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,63 +18,65 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
self.rows = 200
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
self.rows = 200
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db rows %d' %self.rows) tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db rows %d' % self.rows)
tdLog.info("less than 10 rows will go to last file") tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 6 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
sqlcmd = ['import into tb1 values'] tdLog.info("less than 10 rows will go to last file")
for rid in range(1,4):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
for rid in range(6,9):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(6)
tdLog.info("================= step4") tdLog.info("================= step2")
tdDnodes.stop(1) tdLog.info("import 6 sequential data")
tdLog.sleep(5) startTime = self.startTime
tdDnodes.start(1) sqlcmd = ['import into tb1 values']
for rid in range(1, 4):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
for rid in range(6, 9):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step5") tdLog.info("================= step3")
tdLog.info("import 8 data later with partly overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 2 tdSql.checkRows(6)
for rid in range(1,9):
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid)) tdLog.info("================= step4")
tdSql.execute(" ".join(sqlcmd)) tdDnodes.stop(1)
tdLog.sleep(5)
tdDnodes.start(1)
tdLog.info("================= step5")
tdLog.info("import 8 data later with partly overlap")
startTime = self.startTime + 2
for rid in range(1, 9):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

108
tests/pytest/import_merge/importSRestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,62 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, i int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 20 data cover existing data") tdLog.info("import 10 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
for rid in range(1,21): for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid)) tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5") tdLog.info("================= step3")
tdDnodes.forcestop(1) tdSql.query('select * from tb1')
tdDnodes.start(1) tdSql.checkRows(10)
tdLog.sleep(10)
tdLog.info("================= step4")
tdLog.info("import 20 data cover existing data")
startTime = self.startTime - 5
for rid in range(1, 21):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

100
tests/pytest/import_merge/importSpan.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,51 +18,57 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 20 data cover existing data") tdLog.info("import 10 sequential data")
startTime = self.startTime - 5 startTime = self.startTime
for rid in range(1,21): for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid)) tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4")
tdLog.info("import 20 data cover existing data")
startTime = self.startTime - 5
for rid in range(1, 21):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

108
tests/pytest/import_merge/importSubRestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,62 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, i int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 20 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,21):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 10 data totally repetitive") tdLog.info("import 20 sequential data")
startTime = self.startTime + 5 startTime = self.startTime
for rid in range(1,11): for rid in range(1, 21):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid)) tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5") tdLog.info("================= step3")
tdDnodes.forcestop(1) tdSql.query('select * from tb1')
tdDnodes.start(1) tdSql.checkRows(20)
tdLog.sleep(10)
tdLog.info("================= step4")
tdLog.info("import 10 data totally repetitive")
startTime = self.startTime + 5
for rid in range(1, 11):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(20)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

108
tests/pytest/import_merge/importTORestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,56 +18,62 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, i int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 6 data after with overlap") tdLog.info("import 10 sequential data")
startTime = self.startTime + 8 startTime = self.startTime
for rid in range(1,7): for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid)) tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5") tdLog.info("================= step3")
tdDnodes.forcestop(1) tdSql.query('select * from tb1')
tdDnodes.start(1) tdSql.checkRows(10)
tdLog.sleep(10)
tdLog.info("================= step4")
tdLog.info("import 6 data after with overlap")
startTime = self.startTime + 8
for rid in range(1, 7):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(14)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(14)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

112
tests/pytest/import_merge/importTPORestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,58 +18,66 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, i int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 8 sequential data with gap") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,6):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
for rid in range(8,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3") tdLog.info("================= step2")
tdSql.query('select * from tb1') tdLog.info("import 8 sequential data with gap")
tdSql.checkRows(8) startTime = self.startTime
for rid in range(1, 6):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
for rid in range(8, 11):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step4") tdLog.info("================= step3")
tdLog.info("import 8 data after with partly overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 3 tdSql.checkRows(8)
for rid in range(1,9):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step5") tdLog.info("================= step4")
tdDnodes.forcestop(1) tdLog.info("import 8 data after with partly overlap")
tdDnodes.start(1) startTime = self.startTime + 3
tdLog.sleep(10) for rid in range(1, 9):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

104
tests/pytest/import_merge/importTRestart.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,55 +18,59 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, i int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data after") tdLog.info("import 10 sequential data")
startTime = self.startTime + 11 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) for rid in range(1, 11):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5") tdLog.info("================= step3")
tdDnodes.forcestop(1) tdSql.query('select * from tb1')
tdDnodes.start(1) tdSql.checkRows(10)
tdLog.sleep(10)
tdLog.info("================= step4")
tdLog.info("import 1 data after")
startTime = self.startTime + 11
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
tdLog.info("================= step5")
tdDnodes.forcestop(1)
tdDnodes.start(1)
tdLog.sleep(10)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step6")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

96
tests/pytest/import_merge/importTail.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,51 +18,53 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 1 data after") tdLog.info("import 10 sequential data")
startTime += 1 startTime = self.startTime
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4")
tdLog.info("import 1 data after")
startTime += 1
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

100
tests/pytest/import_merge/importTailOverlap.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,53 +18,55 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 10 sequential data") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
for rid in range(1,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid))
startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4") tdLog.info("================= step2")
tdLog.info("import 6 data after with overlap") tdLog.info("import 10 sequential data")
startTime = self.startTime + 8 startTime = self.startTime
for rid in range(1,7): for rid in range(1, 11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime, rid)) tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1 startTime += 1
tdLog.info("================= step3")
tdSql.query('select * from tb1')
tdSql.checkRows(10)
tdLog.info("================= step4")
tdLog.info("import 6 data after with overlap")
startTime = self.startTime + 8
for rid in range(1, 7):
tdSql.execute('import into tb1 values(%ld, %d)' % (startTime, rid))
startTime += 1
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(14)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(14)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

104
tests/pytest/import_merge/importTailPartOverlap.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,53 +18,61 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1) def run(self):
tdDnodes.deploy(1) self.ntables = 1
tdDnodes.start(1) self.startTime = 1520000010000
tdSql.execute('reset query cache') tdDnodes.stop(1)
tdSql.execute('drop database if exists db') tdDnodes.deploy(1)
tdSql.execute('create database db') tdDnodes.start(1)
tdSql.execute('use db')
tdLog.info("================= step1") tdSql.execute('reset query cache')
tdLog.info("create 1 table") tdSql.execute('drop database if exists db')
tdSql.execute('create table tb1 (ts timestamp, speed int)') tdSql.execute('create database db')
tdSql.execute('use db')
tdLog.info("================= step2") tdLog.info("================= step1")
tdLog.info("import 8 sequential data with gap") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, speed int)')
for rid in range(1,6):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
for rid in range(8,11):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid))
tdLog.info("================= step3") tdLog.info("================= step2")
tdSql.query('select * from tb1') tdLog.info("import 8 sequential data with gap")
tdSql.checkRows(8) startTime = self.startTime
for rid in range(1, 6):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
for rid in range(8, 11):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step4") tdLog.info("================= step3")
tdLog.info("import 8 data after with partly overlap") tdSql.query('select * from tb1')
startTime = self.startTime + 3 tdSql.checkRows(8)
for rid in range(1,9):
tdSql.execute('import into tb1 values(%ld, %d)' %(startTime+rid, rid)) tdLog.info("================= step4")
tdLog.info("import 8 data after with partly overlap")
startTime = self.startTime + 3
for rid in range(1, 9):
tdSql.execute(
'import into tb1 values(%ld, %d)' %
(startTime + rid, rid))
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step5")
tdSql.query('select * from tb1')
tdSql.checkRows(11)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

126
tests/pytest/import_merge/importToCommit.py
View File

@ -1,15 +1,15 @@
################################################################### ###################################################################
# Copyright (c) 2016 by TAOS Technologies, Inc. # Copyright (c) 2016 by TAOS Technologies, Inc.
# All rights reserved. # All rights reserved.
# #
# This file is proprietary and confidential to TAOS Technologies. # This file is proprietary and confidential to TAOS Technologies.
# No part of this file may be reproduced, stored, transmitted, # No part of this file may be reproduced, stored, transmitted,
# disclosed or used in any form or by any means other than as # disclosed or used in any form or by any means other than as
# expressly provided by the written permission from Jianhui Tao # expressly provided by the written permission from Jianhui Tao
# #
################################################################### ###################################################################
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import sys import sys
import taos import taos
@ -18,64 +18,68 @@ from util.cases import *
from util.sql import * from util.sql import *
from util.dnodes import * from util.dnodes import *
class TDTestCase: class TDTestCase:
def init(self, conn): def init(self, conn):
tdLog.debug("start to execute %s" % __file__) tdLog.debug("start to execute %s" % __file__)
tdSql.init(conn.cursor()) tdSql.init(conn.cursor())
def run(self):
self.ntables = 1
self.startTime = 1520000010000
tdDnodes.stop(1)
tdDnodes.deploy(1)
tdDnodes.start(1)
tdSql.execute('reset query cache')
tdSql.execute('drop database if exists db')
tdSql.execute('create database db cache 512 tables 10')
tdSql.execute('use db')
tdLog.info("================= step1") def run(self):
tdLog.info("create 1 table") self.ntables = 1
tdSql.execute('create table tb1 (ts timestamp, i int)') self.startTime = 1520000010000
tdLog.info("one block can import 38 records and totally there are 40 blocks")
tdLog.info("================= step2") tdDnodes.stop(1)
tdLog.info('insert data until the first commit') tdDnodes.deploy(1)
dnodesDir = tdDnodes.getDnodesRootDir() tdDnodes.start(1)
dataDir = dnodesDir + '/dnode1/data/data' tdSql.execute('reset query cache')
startTime = self.startTime tdSql.execute('drop database if exists db')
rid0 = 1 tdSql.execute('create database db cache 512 tables 10')
while (True): tdSql.execute('use db')
sqlcmd = 'insert into tb1 values(%ld, %d)' %(startTime+rid0*2, rid0)
tdSql.execute(sqlcmd)
rid0 += 1
vnodes = os.listdir(dataDir)
if (len(vnodes) > 0):
tdLog.info("data is committed, stop inserting")
break
tdLog.info("================= step5") tdLog.info("================= step1")
tdLog.info("import 1 data before ") tdLog.info("create 1 table")
startTime = self.startTime tdSql.execute('create table tb1 (ts timestamp, i int)')
sqlcmd = ['import into tb1 values'] tdLog.info(
for rid in range(3,4): "one block can import 38 records and totally there are 40 blocks")
sqlcmd.append('(%ld, %d)' %(startTime+rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6") tdLog.info("================= step2")
tdSql.execute('reset query cache') tdLog.info('insert data until the first commit')
tdSql.query('select * from tb1 order by ts desc') dnodesDir = tdDnodes.getDnodesRootDir()
tdSql.checkRows(rid0-1+1) dataDir = dnodesDir + '/dnode1/data/data'
startTime = self.startTime
rid0 = 1
while (True):
sqlcmd = 'insert into tb1 values(%ld, %d)' % (
startTime + rid0 * 2, rid0)
tdSql.execute(sqlcmd)
rid0 += 1
vnodes = os.listdir(dataDir)
if (len(vnodes) > 0):
tdLog.info("data is committed, stop inserting")
break
tdLog.info("================= step5")
tdLog.info("import 1 data before ")
startTime = self.startTime
sqlcmd = ['import into tb1 values']
for rid in range(3, 4):
sqlcmd.append('(%ld, %d)' % (startTime + rid, rid))
tdSql.execute(" ".join(sqlcmd))
tdLog.info("================= step6")
tdSql.execute('reset query cache')
tdSql.query('select * from tb1 order by ts desc')
tdSql.checkRows(rid0 - 1 + 1)
tdLog.info("================= step7")
tdSql.execute('reset query cache')
tdSql.query('select count(*) from tb1')
tdSql.checkData(0, 0, rid0 - 1 + 1)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdLog.info("================= step7")
tdSql.execute('reset query cache')
tdSql.query('select count(*) from tb1')
tdSql.checkData(0, 0, rid0-1+1)
def stop(self):
tdSql.close()
tdLog.success("%s successfully executed" % __file__)
tdCases.addWindows(__file__, TDTestCase()) tdCases.addWindows(__file__, TDTestCase())
tdCases.addLinux(__file__, TDTestCase()) tdCases.addLinux(__file__, TDTestCase())

15
tests/pytest/query/tbname.py
View File

@ -26,12 +26,14 @@ class TDTestCase:
def run(self): def run(self):
tdSql.prepare() tdSql.prepare()
tdSql.execute('create table cars (ts timestamp, speed int) tags(id int)') tdSql.execute(
'create table cars (ts timestamp, speed int) tags(id int)')
tdSql.execute("create table carzero using cars tags(0)") tdSql.execute("create table carzero using cars tags(0)")
tdSql.execute("create table carone using cars tags(1)") tdSql.execute("create table carone using cars tags(1)")
tdSql.execute("create table cartwo using cars tags(2)") tdSql.execute("create table cartwo using cars tags(2)")
tdSql.execute("insert into carzero values(now, 100) carone values(now, 110)") tdSql.execute(
"insert into carzero values(now, 100) carone values(now, 110)")
tdSql.query("select * from cars where tbname in ('carzero', 'carone')") tdSql.query("select * from cars where tbname in ('carzero', 'carone')")
tdSql.checkRows(2) tdSql.checkRows(2)
@ -39,13 +41,16 @@ class TDTestCase:
tdSql.query("select * from cars where tbname in ('carzero', 'cartwo')") tdSql.query("select * from cars where tbname in ('carzero', 'cartwo')")
tdSql.checkRows(1) tdSql.checkRows(1)
tdSql.query("select * from cars where id=1 or tbname in ('carzero', 'cartwo')") tdSql.query(
"select * from cars where id=1 or tbname in ('carzero', 'cartwo')")
tdSql.checkRows(2) tdSql.checkRows(2)
tdSql.query("select * from cars where id=1 and tbname in ('carzero', 'cartwo')") tdSql.query(
"select * from cars where id=1 and tbname in ('carzero', 'cartwo')")
tdSql.checkRows(0) tdSql.checkRows(0)
tdSql.query("select * from cars where id=0 and tbname in ('carzero', 'cartwo')") tdSql.query(
"select * from cars where id=0 and tbname in ('carzero', 'cartwo')")
tdSql.checkRows(1) tdSql.checkRows(1)
""" """

4
tests/pytest/util/sql.py
View File

@ -92,10 +92,10 @@ class TDSql:
if data is None: if data is None:
tdLog.info("sql:%.40s, row:%d col:%d data:%s == expect:%s" % tdLog.info("sql:%.40s, row:%d col:%d data:%s == expect:%s" %
(self.sql, row, col, self.queryResult[row][col], data)) (self.sql, row, col, self.queryResult[row][col], data))
else: else:
tdLog.info("sql:%.40s, row:%d col:%d data:%s == expect:%d" % tdLog.info("sql:%.40s, row:%d col:%d data:%s == expect:%d" %
(self.sql, row, col, self.queryResult[row][col], data)) (self.sql, row, col, self.queryResult[row][col], data))
def getData(self, row, col): def getData(self, row, col):
if row < 0: if row < 0: