| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package main |
| |
| import ( |
| "fmt" |
| "github.com/apache/iotdb-client-go/client" |
| ) |
| |
| var session *client.Session |
| |
| func main() { |
| config := client.NewConfig() |
| config.Host = "127.0.0.1" |
| config.Port = "6667" |
| session = client.NewSession(config) |
| session.Open(false, 0) |
| setStorageGroup() |
| deleteStorageGroup() |
| deleteStorageGroups() |
| createTimeseries() |
| createMultiTimeseries() |
| deleteTimeseries() |
| insertStringRecord() |
| insertRecord() |
| insertRecords() |
| insertTablet() |
| insertTablets() |
| deleteData() |
| setTimeZone() |
| fmt.Println(getTimeZone()) |
| executeStatement() |
| executeQueryStatement() |
| executeRawDataQuery() |
| executeBatchStatement() |
| session.Close() |
| } |
| |
| func setStorageGroup() { |
| var storageGroupId = "root.ln1" |
| session.SetStorageGroup(storageGroupId) |
| } |
| |
| func deleteStorageGroup() { |
| var storageGroupId = "root.ln1" |
| session.DeleteStorageGroup(storageGroupId) |
| } |
| |
| func deleteStorageGroups() { |
| var storageGroupId = []string{"root.ln1"} |
| session.DeleteStorageGroups(storageGroupId) |
| } |
| |
| func createTimeseries() { |
| var ( |
| path = "root.sg1.dev1.status" |
| dataType = client.FLOAT |
| encoding = client.PLAIN |
| compressor = client.SNAPPY |
| ) |
| session.CreateTimeseries(path, dataType, encoding, compressor) |
| } |
| |
| func createMultiTimeseries() { |
| var ( |
| paths = []string{"root.sg1.dev1.temperature"} |
| dataTypes = []int32{client.TEXT} |
| encodings = []int32{client.PLAIN} |
| compressors = []int32{client.SNAPPY} |
| ) |
| session.CreateMultiTimeseries(paths, dataTypes, encodings, compressors) |
| } |
| |
| func deleteTimeseries() { |
| var paths = []string{"root.sg1.dev1.status"} |
| session.DeleteTimeseries(paths) |
| } |
| |
| func insertStringRecord() { |
| var ( |
| deviceId = "root.ln.wf02.wt02" |
| measurements = []string{"hardware"} |
| values = []string{"123"} |
| timestamp int64 = 12 |
| ) |
| session.InsertStringRecord(deviceId, measurements, values, timestamp) |
| } |
| |
| func insertRecord() { |
| var ( |
| deviceId = "root.sg1.dev1" |
| measurements = []string{"status"} |
| values = []interface{}{"123"} |
| dataTypes = []int32{client.TEXT} |
| timestamp int64 = 12 |
| ) |
| session.InsertRecord(deviceId, measurements, dataTypes, values, timestamp) |
| } |
| |
| func insertRecords() { |
| var ( |
| deviceId = []string{"root.sg1.dev1"} |
| measurements = [][]string{{"status"}} |
| dataTypes = [][]int32{{client.TEXT}} |
| values = [][]interface{}{{"123"}} |
| timestamp = []int64{12} |
| ) |
| session.InsertRecords(deviceId, measurements, dataTypes, values, timestamp) |
| } |
| |
| func deleteData() { |
| var ( |
| paths = []string{"root.sg1.dev1.status"} |
| startTime int64 = 0 |
| endTime int64 = 12 |
| ) |
| session.DeleteData(paths, startTime, endTime) |
| } |
| |
| func insertTablet() { |
| var ( |
| deviceId = "root.sg1.dev1" |
| measurements = []string{"status", "tem"} |
| dataTypes = []int32{client.INT32, client.INT32} |
| values = make([]interface{}, 2) |
| timestamp = []int64{154, 123} |
| ) |
| values[0] = []int32{777, 6666} |
| values[1] = []int32{888, 999} |
| var tablet = client.Tablet{ |
| DeviceId: deviceId, |
| Measurements: measurements, |
| Values: values, |
| Timestamps: timestamp, |
| Types: dataTypes, |
| } |
| session.InsertTablet(tablet) |
| } |
| |
| func insertTablets() { |
| var ( |
| deviceId1 = "root.sg1.dev1" |
| measurements1 = []string{"status", "tem"} |
| dataTypes1 = []int32{client.INT32, client.INT32} |
| values1 = make([]interface{}, 2) |
| timestamp1 = []int64{154, 123} |
| ) |
| values1[0] = []int32{777, 6666} |
| values1[1] = []int32{888, 999} |
| var tablet1 = client.Tablet{ |
| DeviceId: deviceId1, |
| Measurements: measurements1, |
| Values: values1, |
| Timestamps: timestamp1, |
| Types: dataTypes1, |
| } |
| var ( |
| deviceId2 = "root.sg1.dev2" |
| measurements2 = []string{"status", "tem"} |
| dataTypes2 = []int32{client.INT32, client.INT32} |
| values2 = make([]interface{}, 2) |
| timestamp2 = []int64{154, 123} |
| ) |
| values2[0] = []int32{777, 6666} |
| values2[1] = []int32{888, 999} |
| var tablet2 = client.Tablet{ |
| DeviceId: deviceId2, |
| Measurements: measurements2, |
| Values: values2, |
| Timestamps: timestamp2, |
| Types: dataTypes2, |
| } |
| tablets := []client.Tablet{tablet1, tablet2} |
| session.InsertTablets(tablets) |
| } |
| |
| func setTimeZone() { |
| var timeZone = "GMT" |
| session.SetTimeZone(timeZone) |
| } |
| |
| func getTimeZone() (string, error) { |
| return session.GetTimeZone() |
| } |
| |
| func executeStatement() { |
| var sql = "show storage group" |
| sessionDataSet, err := session.ExecuteStatement(sql) |
| if err != nil { |
| fmt.Println(err) |
| } |
| for i := 0; i < len(sessionDataSet.GetColumnNames()); i++ { |
| println(sessionDataSet.GetColumnNames()[i]) |
| } |
| for { |
| if sessionDataSet.HasNext() { |
| record, err := sessionDataSet.Next() |
| if err != nil { |
| fmt.Println(err) |
| } |
| for i := 0; i < len(record.Fields); i++ { |
| println(record.Fields[i].GetStringValue()) |
| } |
| } else { |
| break |
| } |
| } |
| } |
| |
| func executeQueryStatement() { |
| var sql = "select count(s3) from root.sg1.dev1" |
| sessionDataSet, err := session.ExecuteQueryStatement(sql) |
| if err != nil { |
| fmt.Println(err) |
| } |
| for i := 0; i < len(sessionDataSet.GetColumnNames()); i++ { |
| println(sessionDataSet.GetColumnNames()[i]) |
| } |
| for { |
| if sessionDataSet.HasNext() { |
| record, err := sessionDataSet.Next() |
| if err != nil { |
| fmt.Println(err) |
| } |
| for i := 0; i < len(record.Fields); i++ { |
| println(record.Fields[i].GetLongV()) |
| } |
| } else { |
| break |
| } |
| } |
| } |
| |
| func executeRawDataQuery() { |
| session.ExecuteUpdateStatement("insert into root.ln.wf02.wt02(time,s5) values(1,true)") |
| var ( |
| paths []string = []string{"root.ln.wf02.wt02.s5"} |
| startTime int64 = 1 |
| endTime int64 = 200 |
| ) |
| sessionDataSet, err := session.ExecuteRawDataQuery(paths, startTime, endTime) |
| if err != nil { |
| fmt.Println(err) |
| } |
| for i := 0; i < len(sessionDataSet.GetColumnNames()); i++ { |
| println(sessionDataSet.GetColumnNames()[i]) |
| } |
| for { |
| if sessionDataSet.HasNext() { |
| record, err := sessionDataSet.Next() |
| if err != nil { |
| fmt.Println(err) |
| } |
| println(record.Timestamp) |
| for i := 0; i < len(record.Fields); i++ { |
| switch record.Fields[i].DataType { |
| case "BOOLEAN": |
| println(record.Fields[i].GetBoolV()) |
| break |
| case "INT32": |
| println(record.Fields[i].GetIntV()) |
| break |
| case "INT64": |
| println(record.Fields[i].GetLongV()) |
| break |
| case "FLOAT": |
| println(record.Fields[i].GetFloatV()) |
| break |
| case "DOUBLE": |
| println(record.Fields[i].GetDoubleV()) |
| break |
| case "TEXT": |
| println(string(record.Fields[i].GetBinaryV())) |
| break |
| } |
| |
| } |
| } else { |
| break |
| } |
| } |
| } |
| |
| func executeBatchStatement() { |
| var sqls = []string{"insert into root.ln.wf02.wt02(time,s5) values(1,true)", |
| "insert into root.ln.wf02.wt02(time,s5) values(2,true)"} |
| session.ExecuteBatchStatement(sqls) |
| } |