github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/sql/planner_test.go (about)

     1  // Copyright 2017 The Cockroach Authors.
     2  //
     3  // Use of this software is governed by the Business Source License
     4  // included in the file licenses/BSL.txt.
     5  //
     6  // As of the Change Date specified in that file, in accordance with
     7  // the Business Source License, use of this software will be governed
     8  // by the Apache License, Version 2.0, included in the file
     9  // licenses/APL.txt.
    10  
    11  package sql
    12  
    13  import (
    14  	"context"
    15  	"reflect"
    16  	"testing"
    17  
    18  	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
    19  	"github.com/cockroachdb/cockroach/pkg/sql/sqlbase"
    20  	"github.com/cockroachdb/cockroach/pkg/util/leaktest"
    21  )
    22  
    23  func TestTypeAsString(t *testing.T) {
    24  	defer leaktest.AfterTest(t)()
    25  	ctx := context.Background()
    26  	p := planner{alloc: &sqlbase.DatumAlloc{}}
    27  	testData := []struct {
    28  		expr        tree.Expr
    29  		expected    string
    30  		expectedErr bool
    31  	}{
    32  		{expr: tree.NewDString("foo"), expected: "foo"},
    33  		{
    34  			expr: &tree.BinaryExpr{
    35  				Operator: tree.Concat, Left: tree.NewDString("foo"), Right: tree.NewDString("bar")},
    36  			expected: "foobar",
    37  		},
    38  		{expr: tree.NewDInt(3), expectedErr: true},
    39  	}
    40  
    41  	t.Run("TypeAsString", func(t *testing.T) {
    42  		for _, td := range testData {
    43  			fn, err := p.TypeAsString(ctx, td.expr, "test")
    44  			if err != nil {
    45  				if !td.expectedErr {
    46  					t.Fatalf("expected no error; got %v", err)
    47  				}
    48  				continue
    49  			} else if td.expectedErr {
    50  				t.Fatal("expected error; got none")
    51  			}
    52  			s, err := fn()
    53  			if err != nil {
    54  				t.Fatal(err)
    55  			}
    56  			if s != td.expected {
    57  				t.Fatalf("expected %s; got %s", td.expected, s)
    58  			}
    59  		}
    60  	})
    61  
    62  	t.Run("TypeAsStringArray", func(t *testing.T) {
    63  		for _, td := range testData {
    64  			fn, err := p.TypeAsStringArray(ctx, []tree.Expr{td.expr, td.expr}, "test")
    65  			if err != nil {
    66  				if !td.expectedErr {
    67  					t.Fatalf("expected no error; got %v", err)
    68  				}
    69  				continue
    70  			} else if td.expectedErr {
    71  				t.Fatal("expected error; got none")
    72  			}
    73  			a, err := fn()
    74  			if err != nil {
    75  				t.Fatal(err)
    76  			}
    77  			expected := []string{td.expected, td.expected}
    78  			if !reflect.DeepEqual(a, expected) {
    79  				t.Fatalf("expected %s; got %s", expected, a)
    80  			}
    81  		}
    82  	})
    83  }