odbtest/test/query/testpromdb.go

package main

import (
	//"fmt"
	//"time"
	//"math"
	"strconv"

	"git.wecise.com/wecise/mring/mutil/ccfg"
	. "git.wecise.com/wecise/odbserver/odb"
	"git.wecise.com/wecise/odbserver/odb/promdb/pdbucket"
	"git.wecise.com/wecise/odbserver/odb/test"
	"gitee.com/wecisecode/util/logger"
)

// CGO_ENABLED=1 go run --ldflags '-linkmode external -extldflags "-static"' testpromdb.go

// #cgo LDFLAGS: -L/opt/odbserver/sqlite -lsqlite -ldl
// #include "/opt/odbserver/sqlite/sqlite.h"
// #include <stdint.h>
// #include <stdlib.h>
// extern int64_t uhaha_seed;
// extern int64_t uhaha_ts;
// void uhaha_begin_reader();
// void uhaha_end_reader();

func main() {

	//options := map[string]interface{} {"cache":odb.CacheAll}
	//g,err:= odb.New( options )
	logger.SetConsole(true)
	//option := &StoreOption{Cache:CacheAll}
	option := &Option{Cache: CacheAll, Keyspace: "ooootest", DisableInitialHostLookup: true, DisableNotify: true}
	g, err := test.NewG(option)

	if err != nil {
		logger.Error(err.Error())
	} else {
		defer g.Close()
	}

	var mcfg = ccfg.ModuleConfig("omdb")
	var schema_syncid = mcfg.GetString("cluster.schema.syncid", "")
	logger.Error("===>", schema_syncid)
	//logger.SetRollingDaily("C:/test/zkcron/src/test", "test.log")

	//logger.SetLevel(logger.DEBUG)

	// 测试MQL

	/*rst,meta,err := g.Query(`select e.bk_inst_name as instName,
	       i.name as serverName,
	       i.park_id as parkId
	from /matrix/entity/physical_resource_obj/firewall e join (i:/matrix/entity/physical_resource_obj/server) on e.park_id=i.park_id
	where i.park_id = '133103'`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	/*rst,meta,err := g.Query(`select bk_inst_name
	from /matrix/entity/physical_resource_obj/firewall e left join (i:/matrix/entity/physical_resource_obj/server) on e.park_id=i.park_id
	where i.park_id = '133103'`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	//rst,meta,err := g.Query(` SELECT bk2[0-2,3,4] as fff FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[ 'iparam1', 'iparam2', 'fparam1', 'fparam2', 'sparam1'] FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[-1,-2,-3,-4,-5] FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2 FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[-1 - 1] FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )
	//rst,meta,err := g.Query(` SELECT bk2[1 - -1] FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )
	//rst,meta,err := g.Query(` SELECT bk2[ 4-3] FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )
	//rst,meta,err := g.Query(` SELECT bk2[ 'iparam1', 3-1, 4] FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[ 'iparam1', 1-3, 4] FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )
	//rst,meta,err := g.Query(` SELECT bk2 FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[ 'iparam1', 'iparam2', 2-3, 4 ].time('2020-04-22 08:10', '').(iparam1=1).count(iparam1)  as iparam1  FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[ 'iparam1', 'iparam2', 2-3, 4 ].time('2020-04-22 08:10', '').(iparam1=1).count(iparam1)  as iparam1  FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[ 'iparam1', 'iparam2', 2-3, 4 ].time().(iparam1=1)   FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[  3-4, 5 ].time('2020-05-23 22:24:15', '').([1]=1).title()  FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	/*rst,meta,err := g.Query(`SELECT
	  id,logs.time('2020-05-30 04:36:24','2020-06-30 04:36:24')
	FROM
	  /test/bucketlog`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	//rst,meta,err := g.Query(`SELECT id, disk[1].time(1580755071774, 1690755071774).limit(3)  FROM /matrix/entity/it/it_linux`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[ 'iparam1', 1-3, 4 ].time('2020-04-22', '').filter(fparam1 >= 0.992315).filter(iparam1 = 56).filter(fparam2 <> 0.418309)  as iparam1  FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2.time('2020-04-22', '').filter(fparam1 >= 0.992315).filter(iparam1 = 56).filter(fparam2 <> 0.418309)  as iparam1  FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2.time('2020-04-22', '').(fparam1 >= 0.992315).(iparam1 in [56,99]) FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2[-1 - 1].time('2020-04-22', '').find(fparam1 >= 0.992315).count(fparam1) as iparm1 FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	/*rst,meta,err := g.Query(` SELECT
		 id, bk2
	FROM
		 /matrix/testbucket7/`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	//rst,meta,err := g.Query(` SELECT bk2[-1 - 1].time('2020-04-22', '') FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )
	//rst,meta,err := g.Query(` SELECT bk2[-1 - 1].date('2020-05-23').find(fparam1=3.4) FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2 FROM /matrix/testbucket4  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT id,logs.time('2020-06-15','') FROM /matrix/ where id='linux:wecise'  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` select values[0,2].time(1590231429,1590231439).find(pused='bbbbbbbbbbbbbbbbbbbb') from /test/donghuan/d  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` select values.time(1590231429,1590231439).find(pused='bbbbbbbbbbbbbbbbbbbb') from /test/donghuan/d  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bklog FROM /matrix/testbucket5  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bklog.time('2020-04-22', '').file() FROM /matrix/testbucket5  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2.date("2020-05-15").file() FROM /matrix/testbucket5  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bklog["file*.log"{116669996670004, 116669996680008}] FROM /matrix/testbucket5 `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT id,logs["aaa.log"{142883909780000}]FROM /matrix/entity/it/it_aix where id='it_aix:192.168.190.175' `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2["file1.log"{1,3,6,7}].time('2020-05-15 00:49:59,667', '').find( "twcs skipping" ) FROM /matrix/testbucket5  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2 FROM /matrix/testbucket5  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT 	 bklog["file1.log"].time("2020-06-25","") FROM 	 /matrix/testbucket5 `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(`	select * from /matrix/portal/tools where id in('') and groups['group'] = null or groups['group'] = '' order by seat asc `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(`	select id,name,class,host,iplist,agentstatus,depot['文件系统检测'],config,zabbix['文件系统检测-1.0.0'] from /matrix/system/hostinfo where depot != null limit -1 `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query( `SELECT id,ip,host,disk_perf.time('2020-07-27','2020-07-28').title().stats().limit(1000) FROM /matrix/entity/it/it_aix` )

	//rst,meta,err := g.Query( `SELECT id,ip,host,disk_perf.time('2020-07-27','2020-07-28').min("free", "pfree").max("free").count() FROM /matrix/entity/it/it_aix` )

	//rst,meta,err := g.Query( `SELECT id,ip,host,disk_perf.time('2020-07-27','2020-07-28').title().min("free", "pfree").max("free").count().groupby("mount_point", 1m) FROM /matrix/entity/it/it_aix` )
	//rst,meta,err := g.Query( `SELECT logs.time('2021-04-23','') FROM /matrix/entity/linux where id='linux:node3'` )

	//rst,meta,err := g.Query( `SELECT id,ip,host,disk_perf FROM /matrix/entity/it/it_aix where id='it_aix:192.168.190.175'` )

	//rst,meta,err := g.Query( `SELECT bk2.date("2020-05-15").inst().title() FROM /matrix/test/buckettsdb` )

	//rst,meta,err := g.Query( `select id,logs.time('2021-01-01','2021-05-15').find("ssl_req") from /matrix/entity/linux where id = 'linux:node3'` )
	//rst,meta,err := g.Query( `SELECT id,ip,host,disk_perf.time('2018-07-27','').find($3=5.4) FROM /matrix/entity/it/it_aix  where id = 'it_aix:192.168.190.175'` )
	//rst,meta,err := g.Query( `SELECT id,ip,host FROM /matrix/entity/it/it_aix where id='it_aix:192.168.190.174' or disk_perf.time('2020-07-27','').assert($3 = 5.5) ` )
	//rst,meta,err := g.Query( `select id from /matrix/entity/linux where logs.time('2021-01-01','2021-05-15').find("ssl_req").assert()` )

	//rst,meta,err := g.Query( ` SELECT id FROM /matrix/test/buckettsdb where bk2.date("2020-07-24").assert(iparam1=1)` )

	//rst,meta,err := g.Query( ` SELECT id, bk2.time("2020-05-15", "").title().sum(iparam1).groupby(sparam1) FROM /matrix/test/buckettsdb where bk2.time("2020-05-15", "").assert()` )

	//rst,meta,err := g.Query( ` SELECT id FROM /matrix/test/buckettsdb where bk2.time("2020-05-15", "").sum(iparam1).groupby(sparam1).assert($1='1234567898').assert($2>1, 1)` )

	//rst,meta,err := g.Query( ` SELECT id FROM /matrix/test/buckettsdb where bk2.time("2020-05-15", "").sum(iparam1).groupby(sparam1).assert($2>1, 32%)` )

	//rst,meta,err := g.Query( ` SELECT id FROM /matrix/test/buckettsdb where bk2.time("2020-05-15", "").sum(iparam1).groupby(sparam1).assert($2>1, 5)` )

	//rst,meta,err := g.Query( ` select id from  /matrix/test/oo/wheel where dim.bk2.time("2020-05-15", "").sum(iparam1).groupby(sparam1).assert($2 > 0) ` )

	//rst,meta,err := g.Query( ` select id,wheel["sise","color"] from  /matrix/entity/car/camry where wheel.rotations.time('2021-09-13 00:00:00','').assert() ` )

	//rst,meta,err := g.Query( ` SELECT bklog["file1.log"{1,3,6,7}].time('2020-06-25 00:49:59,667', '').find( "twcs skipping" ) FROM /matrix/test/bucketlog ` )

	//rst,meta,err := g.Query( ` SELECT bklog["file1.log"{1,3,6,7}].time('2020-06-25 00:49:59,667', '') FROM /matrix/test/bucketlog ` )

	//rst,meta,err := g.Query( ` SELECT bklog.time("2020-06-26","").find("add") FROM /matrix/test/bucketlog ` )

	//rst,meta,err := g.Query( ` SELECT bk2[-1 - 1].time("2020-07-24", '').find(fparam1 >= 0.992315).count() as iparm1 FROM /matrix/test/buckettsdb ` )

	/*stat, _ := g.Prepare(`insert into /test/bucketpromdb2 (id, prom2) values (?, ? ) at ?`)
	rst,meta,err := stat.Exec("bucketpromdb2:wecise", []map[string]interface{}{
		 { "__name__":"key1", "__value__":6.0, "__timestamp__":"2021-07-31 11:24:17", "disk":"/opt/matrix", "CPU":"CPU1"},
		 { "__name__":"key2", "__value__":3.8, "__timestamp__":"2021-07-31 11:25:18", "disk":"/opt/matrix", "CPU":"CPU2"},
		 { "__name__":"key3", "__value__":2.9, "__timestamp__":"2021-07-31 11:25:19", "disk":"/opt/matrix", "CPU":"CPU3"},
		 { "__name__":"key48", "__value__":2.9, "__timestamp__":"2021-07-31 11:25:19", "disk":"/opt/matrix", "CPU":"CPU48"} }, "2021-07-31 11:24:17" )*/

	/*rst,meta,err := g.Query( ` insert into /test/bucketpromdb2 (id, prom2) values ('bucketpromdb:wecise',
	[{ '__name__':'key1', '__value__':2.7, '__timestamp__':'2021-07-27 11:24:17', 'disk':'/opt/matrix', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':2.8, '__timestamp__':'2021-07-27 11:25:18', 'disk':'/opt/matrix', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':2.9, '__timestamp__':'2021-07-27 11:25:19', 'disk':'/opt/matrix', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':2.9, '__timestamp__':'2021-07-27 11:26:19', 'disk':'/opt/matrix', 'CPU':'CPU48'}] ) `)*/

	/*rst,meta,err := g.Query( ` insert into /test/bucketpromdb (id, prom) values ('bucketpromdb:wecise',
	[{ 'name':'key1', 'value':2.7, 'timestamp':'2021-07-29 11:24:17', 'disk':'/opt/matrix', 'CPU':'CPU1'}] ) `)*/

	//rst,meta,err := g.Query( ` SELECT prom.stats() FROM /test/bucketpromdb `)

	//rst,meta,err := g.Query( `SELECT  batteryclusterdb.date("2022-09-24").find(name =~ "avgtemperature_c_1|avgtemperature_c_2") FROM 	 /demodata/vessel`)

	//rst,meta,err := g.Query( `insert into /test/bucketpromdb (id, prom) values ('bucketpromdb:wecise', [{ '__name__':'key1.key2.key3', '__value__':2.7, '__timestamp__':'2022-07-28 11:26:00', 'disk':'/opt/matrix', 'CPU':'CPU1'}] ) at '2022-07-28 11:26:00.002'`)

	//rst,meta,err := g.Query( `select id,  prom_str.date('2021-07-31').find(CPU='CPU1').facet("info").groupby('key1', 1h) from /test/promdb_string `)

	//rst,meta,err := g.Query( ` SELECT id, prom_split.date('2021-07-26','2021-07-27','2021-07-28','2021-07-29','2021-07-30','2021-07-31').time("11:") FROM /test/bucketsplit`)

	//rst,meta,err := g.Query( `  SELECT id, prom_split.date('2021-07-26','2021-07-27','2021-07-28','2021-07-29','2021-07-30','2021-07-31').groupby('name').max() FROM /test/bucketsplit `)

	//rst,meta,err := g.Query( `  SELECT id, prom_str.date('2021-07-31').find(value like '这是string*').facet("info", "hello").groupby(1h).outlier()  FROM  /test/promdb_string `)

	//rst,meta,err := g.Query( ` SELECT id, prom_str.date('2021-07-31').facet("info").groupby(1d).outlier()  FROM  /test/promdb_string `)

	//rst,meta,err := g.Query( ` SELECT prom.date('2022-11-28').avg().sigma() FROM 	 /test/bucketpromdb`)

	/*rst,meta,err := g.Query( ` SELECT id, prom_str.date('2021-07-27', '2021-07-28', '2021-07-29', '2021-07-30', '2021-07-31').find(value like '这是string*').facet("error").groupby(1h).avg().sigma()  FROM  /test/promdb_string `)*/

	//rst,meta,err := g.Query( ` SELECT  id, prom.date('2023-07-27') FROM 	 /test/bucketpromdb where id= 'bucketpromdb:wecise11' `)

	/*rst,meta,err := g.Query( ` insert into /test/malert_status (id, prom) values ('8836395498820934919',
	[{ '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 11:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':8.81, '__timestamp__':'2023-07-27 11:25:18', 'disk':'/opt/matrix2', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':2.9, '__timestamp__':'2023-07-27 11:25:19', 'disk':'/opt/matrix3', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':2.9, '__timestamp__':'2023-07-27 11:26:19', 'disk':'/opt/matrix4', 'CPU':'CPU48'}] ) `)*/

	/*rst,meta,err := g.Query( ` insert into /test/promdb_string2 (id, prom_str2) values ('promdb_string2:wecise',
	[{ '__name__':'key1', '__value__':'这是string测试 hello world', '__timestamp__':'2023-07-27 11:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU1'}]) `)*/

	//rst,meta,err := g.Query( `SELECT  prom_nocache.date("2023-07-30").find(CPU="CPU1").find(disk='/opt/matrix12') FROM 	 /test/bucketpromdbnocache`)

	//rst,meta,err := g.Query( `	 SELECT 	 prom_nocache.date('2023-07-27','2023-07-30').time(11:24) FROM 	 /test/bucketpromdbnocache`)

	/*rst,meta,err := g.Query( ` insert into /test/bucketpromdbnocache (id, prom_nocache) values ('bucketpromdbnocache:wecise',
	[{ '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 11:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 11:24:16', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 11:24:15', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':8.81, '__timestamp__':'2023-07-27 11:24:18', 'disk':'/opt/matrix2', 'CPU':'CPU2'},
	 { '__name__':'key2', '__value__':8.81, '__timestamp__':'2023-07-27 11:24:17', 'disk':'/opt/matrix2', 'CPU':'CPU2'},
	 { '__name__':'key2', '__value__':8.81, '__timestamp__':'2023-07-27 11:24:16', 'disk':'/opt/matrix2', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':2.9, '__timestamp__':'2023-07-27 11:25:19', 'disk':'/opt/matrix3', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':2.9, '__timestamp__':'2023-07-27 11:26:19', 'disk':'/opt/matrix4', 'CPU':'CPU48'},
	 { '__name__':'key1', '__value__':2.7, '__timestamp__':'2023-07-28 11:24:17', 'disk':'/opt/matrix5', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':8.82, '__timestamp__':'2023-07-28 11:25:18', 'disk':'/opt/matrix6', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':2.9, '__timestamp__':'2023-07-28 11:25:19', 'disk':'/opt/matrix7', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':2.9, '__timestamp__':'2023-07-28 11:26:19', 'disk':'/opt/matrix8', 'CPU':'CPU48'}] )` )*/

	/*rst,meta,err := g.Query( ` insert into /test/bucketpromdbnocache (id, prom_nocache) values ('bucketpromdbnocache:wecise',
	[{ '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 11:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 11:24:16', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 11:24:15', 'disk':'/opt/matrix1', 'CPU':'CPU1'}] )` )*/

	/*rst,meta,err := g.Query( ` insert into /test/bucketpromdbnocache (id, prom_nocache) values ('bucketpromdbnocache:wecise',
	[{ '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU4'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:24:16', 'disk':'/opt/matrix1', 'CPU':'CPU2'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:24:16', 'disk':'/opt/matrix1', 'CPU':'CPU5'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:24:15', 'disk':'/opt/matrix1', 'CPU':'CPU3'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:24:15', 'disk':'/opt/matrix1', 'CPU':'CPU6'},

	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:25:17', 'disk':'/opt/matrix2', 'CPU':'CPU1'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:25:17', 'disk':'/opt/matrix2', 'CPU':'CPU4'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:25:16', 'disk':'/opt/matrix2', 'CPU':'CPU2'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:25:16', 'disk':'/opt/matrix2', 'CPU':'CPU5'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:25:15', 'disk':'/opt/matrix2', 'CPU':'CPU3'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:25:15', 'disk':'/opt/matrix2', 'CPU':'CPU6'},

	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:26:17', 'disk':'/opt/matrix3', 'CPU':'CPU1'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:26:17', 'disk':'/opt/matrix3', 'CPU':'CPU4'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:26:16', 'disk':'/opt/matrix3', 'CPU':'CPU2'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:26:16', 'disk':'/opt/matrix3', 'CPU':'CPU5'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-27 23:26:15', 'disk':'/opt/matrix3', 'CPU':'CPU3'},
	 { '__name__':'key1', '__value__':2, '__timestamp__':'2023-07-28 00:26:15', 'disk':'/opt/matrix3', 'CPU':'CPU6'}] )` )*/

	/*rst,meta,err := g.Query( ` SELECT
		 prom_nocache.date("2023-07-27").find(disk='/opt/matrix1').time("23:25:17")
	FROM
		 /test/bucketpromdbnocache
		 ` )*/

	//rst,meta,err := g.Query( `SELECT id, prom_split.date('2023-07-26').unit('avg','15m') FROM /test/bucketsplit` )

	/*rst,meta,err := g.Query( `SELECT
		 prom_split.date('2023-07-20').find(name='key1').find(CPU='CPU1').unit("max","12minute")
	FROM
		 /test/bucketsplit` )*/

	//rst,meta,err := g.Query( `SELECT id, prom_split.date('2023-07-26','2023-07-27','2023-07-28','2023-07-29','2023-07-30','2023-07-31').sigma("count", 1h) FROM /test/bucketsplit` )
	//rst,meta,err := g.Query( `SELECT id, prom_str.date('2023-07-27', '2023-07-28', '2023-07-29', '2023-07-30', '2023-07-31').sigma("count", 1h)  FROM  /test/promdb_string` )

	//rst,meta,err := g.Query( `select prom.date("2023-09-27").find(tags='mytag2,mytag4') from /test/bucketpromdb` )

	//rst,meta,err := g.Query( `SELECT id, prom_str.date('2024-06-08').find(value ~ '.*中文.*') FROM  /test/promdb_string` )

	//rst,meta,err := g.Query( ` alter class /test/bucketpromdb11 drop column prom11` )

	for i := 0; i < 1000000; i++ {

		if i%100 == 0 {
			logger.Infof("now %d", i)
		}

		class := "/test/bucketpromdb"
		field := "prom"
		name := "inoutflow"
		labels := map[string]string{"inst": "port" + strconv.Itoa(i)}

		ikey, _ := pdbucket.MakeIKey(1, class, field, name, labels)
		//ikey, _ := NMap2ikey(class, field, name, labels)

		if err := g.GetSession().Exec("insert into promdb_dict(ikey, class, field, name, labels) values(?, ?, ?, ?, ?)", ikey, class, field, name, labels); err != nil {
			logger.Infof("err", err)
		}
	}

	/*g.Query( ` 	insert into /test/promdb_string2 (id, prom_str2) values ('promdb_string2:wecise',
		[{ '__name__':'key1', '__value__':'这是string测试 hello world', '__timestamp__':'2023-07-27 11:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU1'}]) `)

	//rst,meta,err := g.Query( ` select prom_str2.date('2023-07-27') from /test/promdb_string2`)
	rst,meta,err := g.Query( ` select prom_str2 from /test/promdb_string2`)*/

	/*rst,meta,err := g.Query( ` insert into /test/promdb_string (id, prom_str) values ('promdb_string:wecise',
	[{ '__name__':'key1', '__value__':'这是string测试 hello world', '__timestamp__':'2021-07-27 11:24:17', 'disk':'/opt/matrix1', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':'这是string测试 queries: info: client 192.168.174.115#43747', '__timestamp__':'2021-07-27 11:25:18', 'disk':'/opt/matrix2', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':'这是string测试 queries: info: client 192.168.174.115#36176 (rx.thegov.win): query: rx.thegov.win IN A + (192.168.174.124)', '__timestamp__':'2021-07-27 11:25:19', 'disk':'/opt/matrix3', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':'这是string测试', '__timestamp__':'2021-07-27 11:26:19', 'disk':'/opt/matrix4', 'CPU':'CPU48'},
	 { '__name__':'key1', '__value__':'这是string测试', '__timestamp__':'2021-07-28 11:24:17', 'disk':'/opt/matrix5', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':'这是string测试', '__timestamp__':'2021-07-28 11:25:18', 'disk':'/opt/matrix6', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':'这是string测试 host tiger', '__timestamp__':'2021-07-28 11:25:19', 'disk':'/opt/matrix7', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':'这是string测试 homeway', '__timestamp__':'2021-07-28 11:26:19', 'disk':'/opt/matrix8', 'CPU':'CPU48'},
	 { '__name__':'key1', '__value__':'这是string测试', '__timestamp__':'2021-07-29 11:24:17', 'disk':'/opt/matrix9', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':'这是string测试', '__timestamp__':'2021-07-29 11:25:18', 'disk':'/opt/matrix10', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':'这是string测试', '__timestamp__':'2021-07-29 11:25:19', 'disk':'/opt/matrix11', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':'这是string测试 resolver: debug 1: createfetch: deb.thegov.win A', '__timestamp__':'2021-07-29 11:26:19', 'disk':'/opt/matrix12', 'CPU':'CPU48'},
	 { '__name__':'key1', '__value__':"这是string测试 error (network unreachable) resolving './NS/IN': 2001:500:84::b#53", '__timestamp__':'2021-07-30 11:24:17', 'disk':'/opt/matrix12', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':'这是string测试', '__timestamp__':'2021-07-30 11:25:18', 'disk':'/opt/matrix13', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':'这是string测试', '__timestamp__':'2021-07-30 11:25:19', 'disk':'/opt/matrix13', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':'这是string测试', '__timestamp__':'2021-07-30 11:26:19', 'disk':'/opt/matrix13', 'CPU':'CPU48'}] )`)*/

	/* rst,meta,err := g.Query( ` SELECT
		 prom_split.date('2021-07-27')
	FROM
		 /test/bucketsplit`)*/

	/*rst,meta,err := g.Query( `insert into /test/bucketpromdb4 (id, prom4) values ('bucketpromdb4:wecise',
	[{ '__name__':'key1', '__value__':2.7, '__timestamp__':'2021-07-27 11:24:17', 'disk':'/opt/matrix', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':8.8, '__timestamp__':'2021-07-27 11:25:18', 'disk':'/opt/matrix', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':2.9, '__timestamp__':'2021-07-27 11:25:19', 'disk':'/opt/matrix', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':2.9, '__timestamp__':'2021-07-27 11:26:19', 'disk':'/opt/matrix', 'CPU':'CPU48'}] )`)*/

	//rst,meta,err := g.Query( `select prom.date('2022-07-28').time('2022-07-28 11:30', '2022-07-28 11:30').find(name='key1.key2.key3') from /test/bucketpromdb`)

	//rst,meta,err := g.Query( ` SELECT prom2.time('2020-07-24', '').find(value > 2.8).find(CPU !~ "CPU4.*") FROM /test/bucketpromdb2 `)

	//rst,meta,err := g.Query( ` SELECT prom2.time('2020-07-24', '').find(CPU ~ "CPU3.*").xlimit(1) FROM /test/bucketpromdb2 `)

	//rst,meta,err := g.Query( ` SELECT prom2.time('2020-07-24', '').find(name ~ "key1.key2.*").max("value").count() FROM /test/bucketpromdb2 `)

	//-------
	//rst,meta,err := g.Query( ` insert into /test/bucketpromdb/subpromdb (id, prom) values ('subpromdb:wecise', 	[{ '__name__':'key1', '__value__':2.7, '__timestamp__':'2021-07-27 11:24:17', 'disk':'/opt/matrix', 'CPU':'CPU1'}] )  `)
	//rst,meta,err := g.Query( ` select prom.date('2021-07-27').find(name='key1') from /test/bucketpromdb/subpromdb  `)
	//rst,meta,err := g.Query( ` SELECT prom.time('2023-03-03', ' ') FROM /test/bucketpromdb `)
	//rst,meta,err := g.Query( ` SELECT prom.time('2020-07-24', '').find(name = "key1.key2.key4") FROM /test/bucketpromdb `)

	//rst,meta,err := g.Query( ` SELECT  class, id, prom.time('2021-01-01', '') FROM 	 /test/bucketpromdb/ `)
	//rst,meta,err := g.Query( ` SELECT  class, id, prom.time('2021-01-01', '').find(name ~ "key1.key2.*") FROM 	 /test/bucketpromdb/ `)

	//rst,meta,err := g.Query( ` SELECT  class, id, prom.time('2021-01-01', '').find(name ~ "key1.key2.*") FROM 	 /test/bucketpromdb/ `)
	//rst,meta,err := g.Query( ` SELECT prom.time('2020-07-24', '').find(name = "key1.key2.key4").max() FROM /test/bucketpromdb `)

	//rst,meta,err := g.Query( ` SELECT prom2.time('2020-07-24', '').xlimit(1) FROM /test/bucketpromdb2 `)
	//rst,meta,err := g.Query( ` SELECT prom2.time('2020-07-24', '').find(name ~ "key1.key2.*").xlimit(1) FROM /test/bucketpromdb2 `)
	//rst,meta,err := g.Query( ` SELECT prom2.time('2020-07-24', '').find(name ~ "key1.key2.*").max() FROM /test/bucketpromdb2 `)

	//rst,meta,err := g.Query( ` SELECT prom3.time('2020-07-24', '').xlimit(1) FROM /test/bucketpromdb3 `)
	//rst,meta,err := g.Query( ` SELECT prom3.time('2020-07-24', '').find(name ~ "key1.key2.*").xlimit(1) FROM /test/bucketpromdb3 `)
	//rst,meta,err := g.Query( ` SELECT prom3.time('2020-07-24', '').find(name ~ "key1.key2.*").max() FROM /test/bucketpromdb3 `)

	//rst,meta,err := g.Query( ` SELECT prom4.time('2020-07-24', '').xlimit(1) FROM /test/bucketpromdb4 `)
	//rst,meta,err := g.Query( ` SELECT prom4.time('2020-07-24', '').find(name ~ "key1.key2.*").xlimit(1) FROM /test/bucketpromdb4 `)
	//rst,meta,err := g.Query( ` SELECT prom4.time('2020-07-24', '').find(name ~ "key1.key2.*").max() FROM /test/bucketpromdb4 `)

	//rst,meta,err := g.Query( ` SELECT  class, id, prom.time('2021-01-01', '').find(name ~ "key1.key2.*") FROM 	 /test/bucketpromdb/ `)

	//rst,meta,err := g.Query( ` select prom.date('2021-07-27','2021-07-28','2021-07-29','2021-07-30').time(11:24,11:26) from /test/bucketpromdb `)
	//rst,meta,err := g.Query( ` select prom.time('2021-07-27 11:24', '2021-07-27 11:25') from /test/bucketpromdb `)

	//rst,meta,err := g.Query( ` SELECT  class, id, prom.time('2023-01-12', '') FROM 	 /test/bucketpromdb `)
	//rst,meta,err := g.Query( ` 	 insert into  /test/bucketpromdb (id, prom) values ('bucketpromdb:wecise11', [{"__name__":"key1", "__value__": 0.1, "__timestamp__": "2024-06-27 22:01:01" }]) `)

	//bug
	/*rst,meta,err := g.Query( ` 	 	 SELECT
		 id, prom.time('2023-11-28 11:24:00', '2023-11-28 11:25:00').find(name='key1.key2.key3').sum()
	FROM
		 /test/bucketpromdb  where id='bucketpromdb:wecise11'`)*/

	/*rst, meta, err := g.Query(` SELECT
		 prom.date('2023-11-28').find(value < 2.1)
	FROM
		 /test/bucketpromdb `)*/

	//_, meta, err := g.Query(` SELECT  class, id, prom.date('2021-10-28').find(name='key1.key2').xtop('max', 5) FROM	 /test/bucketpromdb/ `)

	/*rst, meta, err := g.Query(`SELECT
		 id, prom.time("2021-07-30 11:24:15","2021-07-30 11:26:19")
	FROM
		 /test/bucketpromdb where id='bucketpromdb:wecise11' `)*/

	//rtn,meta,err := g.Query( ` SELECT  class, id, prom.date('2021-10-28').xlimit(1) FROM 	 /test/bucketpromdb `)
	/*logger.Error( "===>", len(rst[0]["prom"].([][]interface{})))

	rst,meta,err = g.Query( ` SELECT  class, id, prom.time('2020-03-15', '') FROM 	/test/bucketpromdb/subpromdb `)
	logger.Error( "===>", len(rst[0]["prom"].([][]interface{})))

	rst,meta,err = g.Query( ` SELECT  class, id, prom.time('2020-03-15', '') FROM 	/test/bucketpromdb/subpromdb `)
	logger.Error( "===>", len(rst[0]["prom"].([][]interface{})))*/

	//rst,meta,err := g.Query( `  insert into /test/bucketpromdb (id, prom) values ('bucketpromdb:wecise', [{ '__name__':'key1.key2.key3', '__value__':null, '__timestamp__':'2022-12-28 11:32:00', 'disk':'/opt/matrix', 'CPU':'CPU1'}] ) at '2022-12-28 11:32:00'; `)

	//rst,meta,err := g.Query( ` delete prom2 from /test/bucketpromdb2 ; `)
	//rst,meta,err := g.Query( ` delete from /test/bucketpromdb2 with version `)
	//rst,meta,err := g.Query( ` drop class if exists /test/bucketpromdb2 `)

	//stat, _ := g.Prepare(`insert into /test/bucketpromdb2 (id, prom2) values (?, ? ) at ?`)
	//rst, meta, err := stat.Exec("bucketpromdb2:wecise", map[string]interface{} { "__name__":"key1", "__value__":nil, "__timestamp__":"2021-07-31 11:24:17", "disk":"/opt/matrix", "CPU":"CPU1"}, "2021-07-31 11:24:17" )

	//rst,meta,err := g.Query( `insert into /test/bucketpromedb2 (id, prom2) values ('bucketpromedb:wecise', ["key1", 2.6, {"disk":"/opt/matrix", "memory":"CPU1"}] ) at '2020-07-24 10:24:17' `)

	/*rst,meta,err := g.Query( `insert into /test/bucketpromdb2 (id, prom2) values ('bucketpromdb2:wecise', [   ["key1", 2.7, {"disk":"/opt/matrix", "CPU":"CPU1"}],
	  ["key2", 2.8, {"disk":"/opt/matrix", "CPU":"CPU2"}],
	  ["key3", 2.9, {"disk":"/opt/matrix", "CPU":"CPU3"}],
	  ["key4", 3.0, {"disk":"/opt/matrix", "CPU":"CPU4"}],
	  ["key5", 2.9, {"disk":"/opt/matrix", "CPU":"CPU5"}],
	  ["key6", 2.9, {"disk":"/opt/matrix", "CPU":"CPU6"}],
	  ["key7", 3.1, {"disk":"/opt/matrix", "CPU":"CPU7"}],
	  ["key8", 2.9, {"disk":"/opt/matrix", "CPU":"CPU8"}],
	  ["key9", 2.9, {"disk":"/opt/matrix", "CPU":"CPU9"}],
	  ["key10", 2.9, {"disk":"/opt/matrix", "CPU":"CPU10"}],
	  ["key11", 2.9, {"disk":"/opt/matrix", "CPU":"CPU11"}],
	  ["key12", 2.9, {"disk":"/opt/matrix", "CPU":"CPU12"}],
	  ["key13", 2.9, {"disk":"/opt/matrix", "CPU":"CPU13"}],
	  ["key14", 2.9, {"disk":"/opt/matrix", "CPU":"CPU14"}],
	  ["key15", 2.9, {"disk":"/opt/matrix", "CPU":"CPU15"}],
	  ["key16", 2.9, {"disk":"/opt/matrix", "CPU":"CPU16"}],
	  ["key17", 2.9, {"disk":"/opt/matrix", "CPU":"CPU17"}],
	  ["key18", 2.9, {"disk":"/opt/matrix", "CPU":"CPU18"}],
	  ["key19", 2.9, {"disk":"/opt/matrix", "CPU":"CPU19"}],
	  ["key20", 2.9, {"disk":"/opt/matrix", "CPU":"CPU20"}],
	  ["key21", 2.9, {"disk":"/opt/matrix", "CPU":"CPU21"}],
	  ["key22", 2.9, {"disk":"/opt/matrix", "CPU":"CPU22"}],
	  ["key23", 2.9, {"disk":"/opt/matrix", "CPU":"CPU23"}],
	  ["key24", 2.9, {"disk":"/opt/matrix", "CPU":"CPU24"}],
	  ["key25", 2.9, {"disk":"/opt/matrix", "CPU":"CPU25"}],
	  ["key26", 2.9, {"disk":"/opt/matrix", "CPU":"CPU26"}],
	  ["key27", 2.9, {"disk":"/opt/matrix", "CPU":"CPU27"}],
	  ["key28", 2.9, {"disk":"/opt/matrix", "CPU":"CPU28"}],
	  ["key29", 2.9, {"disk":"/opt/matrix", "CPU":"CPU29"}],
	  ["key30", 2.9, {"disk":"/opt/matrix", "CPU":"CPU30"}],
	  ["key31", null, {"disk":"/opt/matrix", "CPU":"CPU31"}],
	  ["key32", 2.9, {"disk":"/opt/matrix", "CPU":"CPU32"}],
	  ["key33", 2.9, {"disk":"/opt/matrix", "CPU":"CPU33"}],
	  ["key34", 2.9, {"disk":"/opt/matrix", "CPU":"CPU34"}],
	  ["key35", 2.9, {"disk":"/opt/matrix", "CPU":"CPU35"}],
	  ["key36", 2.9, {"disk":"/opt/matrix", "CPU":"CPU36"}],
	  ["key37", 2.9, {"disk":"/opt/matrix", "CPU":"CPU37"}],
	  ["key38", null, {"disk":"/opt/matrix", "CPU":"CPU38"}],
	  ["key39", 2.9, {"disk":"/opt/matrix", "CPU":"CPU39"}],
	  ["key40", 2.9, {"disk":"/opt/matrix", "CPU":"CPU40"}],
	  ["key41", 2.9, {"disk":"/opt/matrix", "CPU":"CPU41"}],
	  ["key42", 2.9, {"disk":"/opt/matrix", "CPU":"CPU42"}],
	  ["key43", 2.9, {"disk":"/opt/matrix", "CPU":"CPU43"}],
	  ["key44", 2.9, {"disk":"/opt/matrix", "CPU":"CPU44"}],
	  ["key45", 2.9, {"disk":"/opt/matrix", "CPU":"CPU45"}],
	  ["key46", 2.9, {"disk":"/opt/matrix", "CPU":"CPU46"}],
	  ["key47", 2.9, {"disk":"/opt/matrix", "CPU":"CPU47"}],
	  ["key48", 2.9, {"disk":"/opt/matrix", "CPU":"CPU48"}]
	 ] ) at '2020-07-24 10:24:17'` )*/

	//rst,meta,err := g.Query( `  insert into /test/bucketpromdb (id, prom) values ('bucketpromdb2:wecise', [{ '__name__':'key1.key2.key3', '__value__':null, '__timestamp__':'2022-11-28 11:24:00', 'disk':'/opt/matrix', 'CPU':'CPU1'}] ) at '2022-11-28 11:24:00.000'; `)

	/*rst,meta,err := g.Query( ` insert into /test/bucketpromdb2 (id, prom2) values ('bucketpromdb2:wecise',
	[{ '__name__':'key1', '__value__':2.7, '__timestamp__':'2021-07-27 11:24:17', 'disk':'/opt/matrix', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':8.8, '__timestamp__':'2021-07-27 11:25:18', 'disk':'/opt/matrix', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':2.9, '__timestamp__':'2021-07-27 11:25:19', 'disk':'/opt/matrix', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':2.9, '__timestamp__':'2021-07-27 11:26:19', 'disk':'/opt/matrix', 'CPU':'CPU48'}] )	  `)*/
	//rst,meta,err := g.Query( `drop class if exists /test/bucketpromdb2;	  `)*/

	/*rst,meta,err := g.Query( `create class if not exists /test/bucketpromdb2 (

		host varchar,

		prom2  bucket {
				 "type"  :  "promdb",
				 "single":	true,
				 "ttl"   :   365
			 } 'full',

		keys(host),
		indexes(host)

	) with key=manu, nickname='bucketpromdb2'
							  `)*/

	//rst,meta,err := g.Query( ` insert into /test/buckettsdb (id, bk2[ 'iparam1', 'iparam2', 'fparam1', 'fparam2', 'sparam1', 'vparam1']) values (?, ? ) at ? ` )

	//rst,meta,err := g.Query( ` SELECT prom.time('2021-07-24', '2021-07-31').stats() FROM /test/bucketpromdb ` )

	//rst,meta,err := g.Query( ` SELECT prom.time('2021-07-24', '2021-07-31').find(disk="/opt/matrix").find(CPU="CPU2").find(name="key2").find(value = 2.8).count() FROM /test/bucketpromdb ` )

	//rst,meta,err := g.Query( `select id from  /test/oo/wheel where dim.bk2.time("2020-05-15", "").sum(iparam1).groupby(sparam1).assert($2 > 0)` )

	//rst,meta,err := g.Query( `insert into /test/oo/dimension (id, bk2[ 'iparam1', 'iparam2', 'fparam1', 'fparam2', 'sparam1', 'vparam1']) values ('Dimension:dim1', [1, nil, 3.3, 6.5, '1234567890', 'abcdefghhhhh'] ) at '2020-07-24 10:24:17'` )

	//rst,meta,err := g.Query( `SELECT id,bk2.date("2020-07-24").find(iparam1=1).title() FROM /matrix/test/buckettsdb` )

	/*for i := 1234567890; i < 1234567890+10; i++ {

		if i%2 == 0 {
			cql := fmt.Sprintf(`insert into /test/oo/dimension (id, bk2[ 'iparam1', 'iparam2', 'fparam1', 'fparam2', 'sparam1', 'vparam1']) values ('Dimension:dim1', [1, nil, 3.3, 6.5, '%d', 'abcdefghhhhh'] ) at '2020-07-24 10:24:17'`, i)
			g.Query(cql)
		} else {
			cql := fmt.Sprintf(`insert into /test/oo/dimension (id, bk2[ 'iparam1', 'iparam2', 'fparam1', 'fparam2', 'sparam1', 'vparam1']) values ('Dimension:dim1', [nil, nil, 3.3, 6.5, '%d', 'abcdefghhhhh'] ) at '2020-07-24 10:24:17'`, i)
			g.Query(cql)
		}
	}*/

	/*rst,meta,err := g.Query( ` insert into /test/bucketpromdb (id, prom) values ('bucketpromdb:wecise',
	[{ '__name__':'key1', '__value__':2.7, '__timestamp__':'2021-07-27 11:24:17', 'disk':'/opt/matrix', 'CPU':'CPU1'},
	 { '__name__':'key2', '__value__':2.8, '__timestamp__':'2021-07-27 11:25:18', 'disk':'/opt/matrix', 'CPU':'CPU2'},
	 { '__name__':'key5', '__value__':2.9, '__timestamp__':'2021-07-27 11:25:19', 'disk':'/opt/matrix', 'CPU':'CPU5'},
	 { '__name__':'key48', '__value__':2.9, '__timestamp__':'2021-07-27 11:26:19', 'disk':'/opt/matrix', 'CPU':'CPU48'}] ) ` )*/

	//rst,meta,err := g.Query( ` SELECT prom.time('2020-07-26', '') FROM /test/bucketpromdb ` )

	/*rst,meta,err := g.Query( ` SELECT
		 bk2.stats()
	FROM
		 /matrix/test/buckettsdb ` )*/

	//rst,meta,err := g.Query( ` SELECT bklog.inst() FROM /matrix/test/bucketlog ` )

	//rst,meta,err := g.Query( `SELECT logs["/opt/matrix/tmp/1.log"].date("2020-10-13").find("Duplicate").limit(50) FROM /matrix/entity/linux where id='linux:node3'` )

	//rst,meta,err := g.Query( `SELECT bk2 FROM /matrix/test/buckettsdb` )

	//rst,meta,err := g.Query( `SELECT id, logs.time('2021-03-23','').limit(500) FROM /matrix/entity/linux  limit -1` )

	//rst,meta,err := g.Query( `SELECT logs["/opt/matrix/tmp/1.log"] FROM /matrix/entity/linux where id='linux:node3'` )

	/*rst,meta,err := g.Query( `SELECT
	  id,disk_perf.time('2021-04-01','2021-04-06').find("mount_point" != "/").title().min("free", "pfree").max("pfree").max("free").count().groupby("mount_point", 2m)
	FROM
	  /matrix/entity/linux where id='linux:node3'` )*/

	//rst,meta,err := g.Query( `SELECT id,ip,host,disk_perf.time('2020-07-27 16:43','2020-07-28 16:53').min("free", "pfree").max("free").count().groupby("mount_point", 1m) FROM /matrix/entity/it/it_aix` )

	//rst,meta,err := g.Query( `select id,logs.time('2020-07-31 01:53:01','2020-07-31 01:54:01').stats().title().limit(5000) from it_aix where id='it_aix:192.168.190.174'` )
	/*rst,meta,err := g.Query(`SELECT
		 id,bkdata.time("2020-08-01","").find(vparam1 like '*jj*')
	FROM
		 /matrix/testbucket4 `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	/*rst,meta,err := g.Query(`SELECT
	  bklog.time('2020-06-23 14:50','2020-06-23 15:00').find('twcs'),id
	FROM
	  /matrix/testbucket5 `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	/*rst,meta,err := g.Query(`SELECT
	  id,disk_test.time('2020-07-27','')
	FROM
	  /matrix/entity/it/it_aix `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	/*rst,meta,err := g.Query(`SELECT
		 bkdata,class,day,host,id,name,real,status,tags,vtime
	FROM
		 /matrix/testbucket4`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	//rst,meta,err := g.Query(` select depot['df302'] from /matrix/system/hostinfo `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(` SELECT bk2.time('2020-04-22 08:09', '').filter( "iparam1" <= 2 )  as iparam1  FROM /matrix/testbucket  `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,meta,err := g.Query(`select id, config["aa","bb"], email[0,2] from /matrix/ldap where id='8999302930065828009'`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//bug
	//rst,meta,err := g.Query(`select g1, avg(v1) as avgv1 from "/matrix/testgroup" group by g1`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )
	//rst,meta,err := g.Query(`select avg(v1) as avgv1 from "/matrix/testgroup" `, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//t1 := time.Now()
	//rst,meta,err := g.Query(`select wecise FROM asdf/matrix/devops/event where host = "wecise"`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	//rst,_,err := g.Query(`select * from /matrix/devops/中文测试`)

	/*if err != nil {
		logger.Info("Query error:" + err.Error())
		logger.Warn(meta["type"])
	} else {
		logger.Info("rst ===>", rst)
		//logger.Error("meta ===>", meta)

		if meta["trace"] != nil && len(meta["trace"].([]string)) > 0 {
			for _, msg := range meta["trace"].([]string) {
				logger.Error(msg)
			}
		}

		logger.Warn(meta["columns"])
		logger.Warn(meta["params"])
	}*/
}