odbtest/test/query/testalter.go

package main

import (
	//"fmt"
	"time"

	"gitee.com/wecisecode/util/logger"

	//"git.wecise.com/wecise/odbserver/odb"
	. "git.wecise.com/wecise/odbserver/odb"
	//"git.wecise.com/wecise/odbserver/odb/redisvr"
	"git.wecise.com/wecise/odbserver/odb/test"
)

// CGO_ENABLED=1 go run --ldflags '-linkmode external -extldflags "-static"' testalter.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 )

	//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()
	}

	//logger.SetRollingDaily("C:/test/zkcron/src/test", "test.log")
	logger.SetConsole(true)
	//logger.SetLevel(logger.DEBUG)

	// 测试 返回树形结构
	/*
		str,err  := g.GetClassChildren(-1)
		if err != nil {
			fmt.Println("GetClassChildren error:"+err.Error())
		}else{
			fmt.Println("Children:=>" + str)
		}
	*/
	// 测试 插入、更新类，删除field ,"cid":2,

	// 测试 删除类

	/*
		list := g.GetClassFields("/matrix/entity", true, true)

		for i := range list {
			if field, ok := g.Relations[list[i]]; ok {
				fmt.Println("rrrrrrr",field)
			}
			if field, ok := g.Fields[list[i]]; ok {

				// patch by lzg
				if field.Ftype == "smallint" || field.Ftype == "enum" {
					g.EnumClassField("/matrix/entity", field.Name)
				}else if field.Ftype == "bucket" {
					fmt.Println("====>",field)
					g.BucketParams("/matrix/entity", field.Name)
				}

			}
		}

	*/

	// 测试 插入对象

	/*
		objsstr := `[ {"class":"test","id":11}, {"class":"test"}, {"class":"test2","vtime":"1970-01-01T00:00:00Z"}]`
		if err := g.CreateObjectsFromjson(objsstr,[]string{"class","aaa"}) ;err != nil {
			logger.Fatal(err.Error())
		}
	*/

	/*
		objs := make([]map[string]interface{},3)

		objs[0] = map[string]interface{}{"class":"test","id" :"1234567890"}
		objs[1] = map[string]interface{}{"class":"test"}
		objs[2] = map[string]interface{}{"class":"test2","vtime":"1970-01-01T00:00:00Z"}

		if err := g.CreateObjectsFromMap(objs,[]string{"class","aaa"}) ;err != nil {
			logger.Fatal(err.Error())
		}
	*/

	// 测试 返回对象名称
	/*
		if rtn,err := g.GetDisplayName([]string{"class","id"},"") ;err != nil {
			logger.Fatal(err.Error())
		}else{
			for k,v := range rtn {
				fmt.Printf(" %s :",k)
				for i:=0 ;i<len(v) ;i++ {
					fmt.Printf(" %s :",v)
				}
				fmt.Println()
			}
		}

		if rtn,err := g.GetDisplayName([]string{"class","id"},"1") ;err != nil {
			logger.Fatal(err.Error())
		}else{
			for k,v := range rtn {
				fmt.Printf(" %s :",k)
				for i:=0 ;i<len(v) ;i++ {
					fmt.Printf(" %s :",v)
				}
				fmt.Println()
			}
		}
	*/

	/*
		rst,meta, err := g.Query(` alter class  /matrix/testbucket5 modify bk2 add pattern {
		"files": [
			"*.aa"
		],
		"pattern": [
			"YYYY-MM-DD HH:mm:ss,SSS"
		]} `,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})
	*/
	//rst,meta, err := g.Query(` alter class /matrix/testbucket4 drop column bk1 `,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})

	/*rst,meta,err := g.Query(`alter class /matrix/entity/linux add column llllogs bucket {
	 "files": [
	  "*.log"
	 ],
	 "pattern": [
	  "YYYY-MM-DD HH:mm:ss"
	 ],
	 "ttl": 365,
	 "type": "bitlog"
	} "系统日志";`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	//rst,meta, err := g.Query(` alter class /matrix/entity/linux add column cpu_perf bucket { "params": [ ["cpuutilization", "float", "%", "${desc[5]}"] ], "ttl": 365, "type": "tsdb" } 'cpu_perf'  `,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})

	/*rst,meta, err := g.Query(` alter class /matrix/entity modify type merge enum { "1000": [ "computer", "服务器" ],
	  "1100": [ ] }`,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})*/

	//rst,meta, err := g.Query(` alter class /matrix/entity/wheel add index column screw screw[4..4] '螺丝'; `,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})

	/*rst,meta, err := g.Query(` alter /matrix/entity/it/it_aix add column errcol bucket 		{
			"desc": [
					"空闲磁盘",
					"空闲磁盘百分比",
					"磁盘总空间",
					"已使用磁盘空间百分比",
					"文件系统"
			],
			"params": [

					["free", "string", "MB", "${desc[0]}"],
					["pfree", "string", "%", "${desc[1]}"],
					["used", "string", "MB", "${desc[2]}"],
					["total", "string", "MB", "${desc[3]}"],
					["pused", "string", "%", "${desc[4]}"]
			],
			"ttl": 365,
			"type": "tsdb"
	}	"磁盘测试"; `,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})*/

	/*rst,meta, err := g.Query(`
	alter class /m3event/entity/node/ add  column 	promedb			bucket 		{
				"ttl": 365,
				"type": "promdb"
		}	"promedb"
	`,&QueryMeta{Return: ReturnAll})*/

	/*rst, meta, err := g.Query(`
	  alter class /test/alter with syncdc={"keyspace":"matrix","dc":"dc2"}
	`)*/

	rst, meta, err := g.Query(`
	   alter class /test/bucketpromdb with syncdc={}
	`)

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

	/*rst,meta, err := g.Query(`
	alter class  /test/enum modify v_enum merge enum  {
			"1":["computer", "新的新的服务器"],
			"2":["network", "网络设备"],
			"3":["software", "软件"]}
	`,&QueryMeta{Return: ReturnAll})*/
	//rst,meta, err := g.Query(` alter class MachineToolSpecification add index column location6 varchar `,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})
	//rst,meta, err := g.Query(` alter class MachineToolSpecification drop column location6 `,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})
	//rst,meta, err := g.Query(`select * from MachineToolSpecification`,&QueryMeta{Return: ReturnAll, MinAsteriskField: true, KeepClassID: false})

	//rst,meta,err := g.Query(`alter class /matrix/jobs/jobdef add index column arg list<varchar>`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )

	/*
			rst,meta,err := g.Query(` alter class /matrix/entity/node add column cpu_metric  bucket {
		        "crc": [
		                "nodeid",
				"CPU_ID"
		        ],
		        "desc": [
				"NODE ID",
				"CPU ID",
				"SYSCP_WHSC",
				"User to System CPU(Percent)",
				"STEAL_WHSC",
				"Busy CPU(Percent)",
				"Time Stamp",
				"I/O Wait(Percent)",
				"WAITC_WHSC",
				"System CPU(Percent)",
				"TMZDIFF",
				"BUSYC_WHSC",
				"User CPU(Percent)",
				"WRITETIME",
				"Steal CPU(Percent)",
				"Idle CPU(Percent)",
				"IDLEC_WHSC",
				"User Nice CPU(Percent)"
		        ],
		        "params": [
		                [
		                        "nodeid",
		                        "string",
		                        "",
		                        "${desc[0]}"
		                ],
		                [
		                        "CPU_ID",
		                        "string",
		                        "",
		                        "${desc[1]}"
		                ],
		                [
		                        "SYSCP_WHSC",
		                        "int",
		                        "",
		                        "${desc[2]}"
		                ],
		                [
		                        "User_Sys_Pct",
		                        "float",
		                        "%",
		                        "${desc[3]}"
		                ],
		                [
		                        "STEAL_WHSC",
		                        "int",
		                        "",
		                        "${desc[4]}"
		                ],
		                [
		                        "Busy_CPU",
		                        "float",
		                        "%",
		                        "${desc[5]}"
		                ],
		                [
		                        "Timestamp",
		                        "string",
		                        "",
		                        "${desc[6]}"
		                ],
		                [
		                        "Wait_IO_CPU",
		                        "float",
		                        "%",
		                        "${desc[7]}"
		                ],
		                [
		                        "WAITC_WHSC",
		                        "int",
		                        "",
		                        "${desc[8]}"
		                ],
		                [
		                        "System_CPU",
		                        "float",
		                        "%",
		                        "${desc[9]}"
		                ],
		                [
		                        "TMZDIFF",
		                        "int",
		                        "",
		                        "${desc[10]}"
		                ],
		                [
		                        "BUSYC_WHSC",
		                        "int",
		                        "",
		                        "${desc[11]}"
		                ],
		                [
		                        "User_CPU",
		                        "float",
		                        "%",
		                        "${desc[12]}"
		                ],
		                [
		                        "WRITETIME",
		                        "string",
		                        "",
		                        "${desc[13]}"
		                ],
		                [
		                        "Steal_CPU_Percent",
		                        "float",
		                        "%",
		                        "${desc[14]}"
		                ],
		                [
		                        "Idle_CPU",
		                        "float",
		                        "%",
		                        "${desc[15]}"
		                ],
		                [
		                        "IDLEC_WHSC",
		                        "int",
		                        "",
		                        "${desc[16]}"
		                ],
		                [
		                        "User_Nice_CPU",
		                        "float",
		                        "%",
		                        "${desc[17]}"
		                ]
		        ],
		        "ttl": 365,
		        "type": "tsdb"
		 }      "KLZ_CPU";`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false} )*/

	// 测试 Alter Table
	/*
		for i:=0 ; i<1000 ;i++ {
			sql := fmt.Sprintf(`ALTER  TABLE object ADD H%d %s`,i,"text")
			logger.Debugf(sql)
			if err := g.GetSession().Query(sql).Consistency(gocql.Quorum).Exec(); err != nil {
				logger.Fatalf("ADD ERROR %v",err)
			}

	*/
	/*
		for i:=0 ; i<1000 ;i++ {
			sql := fmt.Sprintf(`ALTER TABLE object DROP  H%d `,i)
			logger.Debugf(sql)
			if err := g.GetSession().Query(sql).Consistency(gocql.Quorum).Exec(); err != nil {
				logger.Fatalf("DROP ERROR %v",err)
			}
		}
	*/

	/*rst,meta,err := g.Query(`alter class  /matrix/test add column bbaa14 	bucket {
		"files": [
			"*.log"
		],
		"sample": [
			"2020-05-15 00:49:59,666"
		],
		"ttl": 365,
		"type": "bitlog"
	}`)*/

	//g.SchemaChangeNotify(CacheField | CacheClass | CacheRels | CacheBulk | CacheTSDB | CacheBitLog)

	/*if def, err := g.ClassDefine(3) ; err == nil {
		logger.Warn( def )
	}*/

	/*rst,meta,err := g.Query(`create class /matrix/testaa (
		bbssss varchar "22222",
		keys(bbssss),
		index(bbssss)
	)`)
	*/

	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"])
	}

	time.Sleep(10 * time.Second)
}