database/iotdb_std_test.go - iotdb-client-go - Git at Google

 /*
  * 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 iotdb_go

 import (
 	"context"
 	"database/sql"
 	"database/sql/driver"
 	"errors"
 	"testing"

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

 var stdConn *sql.DB

 func init() {
 	var err error
 	stdConn, err = sql.Open("iotdb", defaultAddress)
 	if err != nil {
 		panic(err)
 	}
 }

 // ==================== INSERT Operations ====================

 // TestStd_BasicInsert verifies a single-row INSERT with mixed types.
 func TestStd_BasicInsert(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test in short mode")
 	}

 	sg := "root.std_test"
 	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
 	require.NoError(t, err)
 	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.status WITH DATATYPE=BOOLEAN, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"INSERT INTO "+sg+".d1(timestamp, status, temp) VALUES (?, ?, ?)",
 		1, true, 25.5)
 	require.NoError(t, err)

 	// Verify inserted data can be read back
 	rows, err := stdConn.QueryContext(context.Background(), "SELECT status, temp FROM "+sg+".d1")
 	require.NoError(t, err)
 	defer rows.Close()

 	require.True(t, rows.Next())
 	var ts int64
 	var status bool
 	var temp float64
 	err = rows.Scan(&ts, &status, &temp)
 	require.NoError(t, err)
 	assert.True(t, status)
 	assert.InDelta(t, 25.5, temp, 0.1)
 	require.NoError(t, rows.Err())
 }

 // TestStd_MultiValueInsert verifies inserting multiple rows in a single statement.
 func TestStd_MultiValueInsert(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test in short mode")
 	}

 	sg := "root.std_multi"
 	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
 	require.NoError(t, err)
 	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.status WITH DATATYPE=BOOLEAN, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"INSERT INTO "+sg+".d1(timestamp, status, temp) VALUES (?, ?, ?), (?, ?, ?)",
 		1, true, 25.0,
 		2, false, 26.0)
 	require.NoError(t, err)

 	// Verify both rows exist
 	rows, err := stdConn.QueryContext(context.Background(), "SELECT temp FROM "+sg+".d1 ORDER BY time ASC")
 	require.NoError(t, err)
 	defer rows.Close()

 	var count int
 	for rows.Next() {
 		count++
 	}
 	assert.Equal(t, 2, count)
 	require.NoError(t, rows.Err())
 }

 // TestStd_InsertTypes verifies INSERT with INT64 and FLOAT types.
 func TestStd_InsertTypes(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test in short mode")
 	}

 	sg := "root.std_types"
 	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
 	require.NoError(t, err)
 	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.int_val WITH DATATYPE=INT64, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.float_val WITH DATATYPE=FLOAT, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"INSERT INTO "+sg+".d1(timestamp, int_val, float_val) VALUES (?, ?, ?)",
 		1, 1718193600000, 99.9)
 	require.NoError(t, err)

 	// Verify values
 	row := stdConn.QueryRowContext(context.Background(),
 		"SELECT int_val, float_val FROM "+sg+".d1")
 	var ts int64
 	var intVal int64
 	var floatVal float64
 	err = row.Scan(&ts, &intVal, &floatVal)
 	require.NoError(t, err)
 	assert.Equal(t, int64(1718193600000), intVal)
 	assert.InDelta(t, 99.9, floatVal, 0.1)
 }

 // ==================== Basic Query ====================

 // TestStd_QueryBasic verifies a round-trip INSERT then SELECT.
 func TestStd_QueryBasic(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test in short mode")
 	}

 	sg := "root.std_query"
 	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
 	require.NoError(t, err)
 	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"INSERT INTO "+sg+".d1(timestamp, temp) VALUES (?, ?)",
 		1704067200000, 25.5)
 	require.NoError(t, err)

 	rows, err := stdConn.QueryContext(context.Background(), "SELECT temp FROM "+sg+".d1")
 	require.NoError(t, err)
 	defer rows.Close()

 	require.True(t, rows.Next())
 	var ts int64
 	var temp float64
 	err = rows.Scan(&ts, &temp)
 	require.NoError(t, err)
 	assert.InDelta(t, 25.5, temp, 0.1)
 	require.NoError(t, rows.Err())
 }

 // ==================== Struct Scanning ====================

 // TestStd_ScanStruct verifies scanning multiple columns into struct fields.
 func TestStd_ScanStruct(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test in short mode")
 	}

 	sg := "root.std_scan"
 	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
 	require.NoError(t, err)
 	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"CREATE TIMESERIES "+sg+".d1.hum WITH DATATYPE=DOUBLE, ENCODING=PLAIN")
 	require.NoError(t, err)

 	_, err = stdConn.ExecContext(context.Background(),
 		"INSERT INTO "+sg+".d1(timestamp, temp, hum) VALUES (?, ?, ?)",
 		1704067200000, 25.5, 60.5)
 	require.NoError(t, err)

 	rows, err := stdConn.QueryContext(context.Background(), "SELECT temp, hum FROM "+sg+".d1")
 	require.NoError(t, err)
 	defer rows.Close()

 	require.True(t, rows.Next())

 	type Reading struct {
 		Time int64
 		Temp float64
 		Hum  float64
 	}
 	var r Reading
 	err = rows.Scan(&r.Time, &r.Temp, &r.Hum)
 	require.NoError(t, err)
 	assert.InDelta(t, 25.5, r.Temp, 0.1)
 	assert.InDelta(t, 60.5, r.Hum, 0.1)
 	require.NoError(t, rows.Err())
 }

 // ==================== Metadata Queries ====================

 // TestStd_ShowDatabases verifies SHOW DATABASES returns at least one result.
 func TestStd_ShowDatabases(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping integration test in short mode")
 	}

 	rows, err := stdConn.QueryContext(context.Background(), "SHOW DATABASES")
 	require.NoError(t, err)
 	defer rows.Close()

 	var count int
 	for rows.Next() {
 		count++
 	}
 	assert.GreaterOrEqual(t, count, 1)
 	require.NoError(t, rows.Err())
 }

 // ==================== Transactions ====================

 // TestStd_BeginUnsupported verifies that Begin reports transactions as
 // unsupported rather than returning a fake no-op transaction.
 func TestStd_BeginUnsupported(t *testing.T) {
 	tx, err := (&stdDriver{}).Begin()
 	assert.Nil(t, tx)
 	assert.ErrorIs(t, err, ErrTransactionsUnsupported)
 }

 // TestStd_BeginTxUnsupported verifies the same for the context-aware BeginTx.
 func TestStd_BeginTxUnsupported(t *testing.T) {
 	tx, err := (&stdDriver{}).BeginTx(context.Background(), driver.TxOptions{})
 	assert.Nil(t, tx)
 	assert.ErrorIs(t, err, ErrTransactionsUnsupported)
 }

 // TestStd_DBBeginUnsupported verifies the error surfaces through database/sql.
 func TestStd_DBBeginUnsupported(t *testing.T) {
 	_, err := stdConn.Begin()
 	assert.True(t, errors.Is(err, ErrTransactionsUnsupported))
 }
	/*
	* 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 iotdb_go

	import (
	"context"
	"database/sql"
	"database/sql/driver"
	"errors"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	)

	var stdConn *sql.DB

	func init() {
	var err error
	stdConn, err = sql.Open("iotdb", defaultAddress)
	if err != nil {
	panic(err)
	}
	}

	// ==================== INSERT Operations ====================

	// TestStd_BasicInsert verifies a single-row INSERT with mixed types.
	func TestStd_BasicInsert(t *testing.T) {
	if testing.Short() {
	t.Skip("skipping integration test in short mode")
	}

	sg := "root.std_test"
	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
	require.NoError(t, err)
	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.status WITH DATATYPE=BOOLEAN, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"INSERT INTO "+sg+".d1(timestamp, status, temp) VALUES (?, ?, ?)",
	1, true, 25.5)
	require.NoError(t, err)

	// Verify inserted data can be read back
	rows, err := stdConn.QueryContext(context.Background(), "SELECT status, temp FROM "+sg+".d1")
	require.NoError(t, err)
	defer rows.Close()

	require.True(t, rows.Next())
	var ts int64
	var status bool
	var temp float64
	err = rows.Scan(&ts, &status, &temp)
	require.NoError(t, err)
	assert.True(t, status)
	assert.InDelta(t, 25.5, temp, 0.1)
	require.NoError(t, rows.Err())
	}

	// TestStd_MultiValueInsert verifies inserting multiple rows in a single statement.
	func TestStd_MultiValueInsert(t *testing.T) {
	if testing.Short() {
	t.Skip("skipping integration test in short mode")
	}

	sg := "root.std_multi"
	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
	require.NoError(t, err)
	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.status WITH DATATYPE=BOOLEAN, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"INSERT INTO "+sg+".d1(timestamp, status, temp) VALUES (?, ?, ?), (?, ?, ?)",
	1, true, 25.0,
	2, false, 26.0)
	require.NoError(t, err)

	// Verify both rows exist
	rows, err := stdConn.QueryContext(context.Background(), "SELECT temp FROM "+sg+".d1 ORDER BY time ASC")
	require.NoError(t, err)
	defer rows.Close()

	var count int
	for rows.Next() {
	count++
	}
	assert.Equal(t, 2, count)
	require.NoError(t, rows.Err())
	}

	// TestStd_InsertTypes verifies INSERT with INT64 and FLOAT types.
	func TestStd_InsertTypes(t *testing.T) {
	if testing.Short() {
	t.Skip("skipping integration test in short mode")
	}

	sg := "root.std_types"
	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
	require.NoError(t, err)
	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.int_val WITH DATATYPE=INT64, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.float_val WITH DATATYPE=FLOAT, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"INSERT INTO "+sg+".d1(timestamp, int_val, float_val) VALUES (?, ?, ?)",
	1, 1718193600000, 99.9)
	require.NoError(t, err)

	// Verify values
	row := stdConn.QueryRowContext(context.Background(),
	"SELECT int_val, float_val FROM "+sg+".d1")
	var ts int64
	var intVal int64
	var floatVal float64
	err = row.Scan(&ts, &intVal, &floatVal)
	require.NoError(t, err)
	assert.Equal(t, int64(1718193600000), intVal)
	assert.InDelta(t, 99.9, floatVal, 0.1)
	}

	// ==================== Basic Query ====================

	// TestStd_QueryBasic verifies a round-trip INSERT then SELECT.
	func TestStd_QueryBasic(t *testing.T) {
	if testing.Short() {
	t.Skip("skipping integration test in short mode")
	}

	sg := "root.std_query"
	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
	require.NoError(t, err)
	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"INSERT INTO "+sg+".d1(timestamp, temp) VALUES (?, ?)",
	1704067200000, 25.5)
	require.NoError(t, err)

	rows, err := stdConn.QueryContext(context.Background(), "SELECT temp FROM "+sg+".d1")
	require.NoError(t, err)
	defer rows.Close()

	require.True(t, rows.Next())
	var ts int64
	var temp float64
	err = rows.Scan(&ts, &temp)
	require.NoError(t, err)
	assert.InDelta(t, 25.5, temp, 0.1)
	require.NoError(t, rows.Err())
	}

	// ==================== Struct Scanning ====================

	// TestStd_ScanStruct verifies scanning multiple columns into struct fields.
	func TestStd_ScanStruct(t *testing.T) {
	if testing.Short() {
	t.Skip("skipping integration test in short mode")
	}

	sg := "root.std_scan"
	_, err := stdConn.ExecContext(context.Background(), "CREATE DATABASE "+sg)
	require.NoError(t, err)
	defer func() { _, _ = stdConn.ExecContext(context.Background(), "DELETE DATABASE "+sg) }()

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.temp WITH DATATYPE=FLOAT, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"CREATE TIMESERIES "+sg+".d1.hum WITH DATATYPE=DOUBLE, ENCODING=PLAIN")
	require.NoError(t, err)

	_, err = stdConn.ExecContext(context.Background(),
	"INSERT INTO "+sg+".d1(timestamp, temp, hum) VALUES (?, ?, ?)",
	1704067200000, 25.5, 60.5)
	require.NoError(t, err)

	rows, err := stdConn.QueryContext(context.Background(), "SELECT temp, hum FROM "+sg+".d1")
	require.NoError(t, err)
	defer rows.Close()

	require.True(t, rows.Next())

	type Reading struct {
	Time int64
	Temp float64
	Hum float64
	}
	var r Reading
	err = rows.Scan(&r.Time, &r.Temp, &r.Hum)
	require.NoError(t, err)
	assert.InDelta(t, 25.5, r.Temp, 0.1)
	assert.InDelta(t, 60.5, r.Hum, 0.1)
	require.NoError(t, rows.Err())
	}

	// ==================== Metadata Queries ====================

	// TestStd_ShowDatabases verifies SHOW DATABASES returns at least one result.
	func TestStd_ShowDatabases(t *testing.T) {
	if testing.Short() {
	t.Skip("skipping integration test in short mode")
	}

	rows, err := stdConn.QueryContext(context.Background(), "SHOW DATABASES")
	require.NoError(t, err)
	defer rows.Close()

	var count int
	for rows.Next() {
	count++
	}
	assert.GreaterOrEqual(t, count, 1)
	require.NoError(t, rows.Err())
	}

	// ==================== Transactions ====================

	// TestStd_BeginUnsupported verifies that Begin reports transactions as
	// unsupported rather than returning a fake no-op transaction.
	func TestStd_BeginUnsupported(t *testing.T) {
	tx, err := (&stdDriver{}).Begin()
	assert.Nil(t, tx)
	assert.ErrorIs(t, err, ErrTransactionsUnsupported)
	}

	// TestStd_BeginTxUnsupported verifies the same for the context-aware BeginTx.
	func TestStd_BeginTxUnsupported(t *testing.T) {
	tx, err := (&stdDriver{}).BeginTx(context.Background(), driver.TxOptions{})
	assert.Nil(t, tx)
	assert.ErrorIs(t, err, ErrTransactionsUnsupported)
	}

	// TestStd_DBBeginUnsupported verifies the error surfaces through database/sql.
	func TestStd_DBBeginUnsupported(t *testing.T) {
	_, err := stdConn.Begin()
	assert.True(t, errors.Is(err, ErrTransactionsUnsupported))
	}