How to use Less method of order Package

1// Licensed to the Apache Software Foundation (ASF) under one2// or more contributor license agreements.  See the NOTICE file3// distributed with this work for additional information4// regarding copyright ownership.  The ASF licenses this file5// to you under the Apache License, Version 2.0 (the6// "License"); you may not use this file except in compliance7// with the License.  You may obtain a copy of the License at8//9// http://www.apache.org/licenses/LICENSE-2.010//11// Unless required by applicable law or agreed to in writing, software12// distributed under the License is distributed on an "AS IS" BASIS,13// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.14// See the License for the specific language governing permissions and15// limitations under the License.16package metadata17import (18	"encoding/binary"19	"testing"20	"github.com/apache/arrow/go/v9/parquet"21	"github.com/apache/arrow/go/v9/parquet/schema"22	"github.com/stretchr/testify/assert"23	"github.com/stretchr/testify/require"24)25func TestSignedByteArrayCompare(t *testing.T) {26	s := ByteArrayStatistics{27		statistics: statistics{28			order: schema.SortSIGNED,29		},30	}31	// signed byte array comparison is only used for Decimal comparison.32	// when decimals are encoded as byte arrays they use twos compliment33	// big-endian encoded values. Comparisons of byte arrays of unequal34	// types need to handle sign extension.35	tests := []struct {36		b     []byte37		order int38	}{39		{[]byte{0x80, 0x80, 0, 0}, 0},40		{[]byte{ /*0xFF,*/ 0x80, 0, 0}, 1},41		{[]byte{0xFF, 0x80, 0, 0}, 1},42		{[]byte{ /*0xFF,*/ 0xFF, 0x01, 0}, 2},43		{[]byte{ /*0xFF, 0xFF,*/ 0x80, 0}, 3},44		{[]byte{ /*0xFF,*/ 0xFF, 0x80, 0}, 3},45		{[]byte{0xFF, 0xFF, 0x80, 0}, 3},46		{[]byte{ /*0xFF,0xFF,0xFF,*/ 0x80}, 4},47		{[]byte{ /*0xFF,0xFF,0xFF*/ 0xFF}, 5},48		{[]byte{ /*0, 0,*/ 0x01, 0x01}, 6},49		{[]byte{ /*0,*/ 0, 0x01, 0x01}, 6},50		{[]byte{0, 0, 0x01, 0x01}, 6},51		{[]byte{ /*0,*/ 0x01, 0x01, 0}, 7},52		{[]byte{0x01, 0x01, 0, 0}, 8},53	}54	for i, tt := range tests {55		// empty array is always the smallest56		assert.Truef(t, s.less(parquet.ByteArray{}, parquet.ByteArray(tt.b)), "case: %d", i)57		assert.Falsef(t, s.less(parquet.ByteArray(tt.b), parquet.ByteArray{}), "case: %d", i)58		// equals is always false59		assert.Falsef(t, s.less(parquet.ByteArray(tt.b), parquet.ByteArray(tt.b)), "case: %d", i)60		for j, case2 := range tests {61			var fn func(assert.TestingT, bool, string, ...interface{}) bool62			if tt.order < case2.order {63				fn = assert.Truef64			} else {65				fn = assert.Falsef66			}67			fn(t, s.less(parquet.ByteArray(tt.b), parquet.ByteArray(case2.b)),68				"%d (order: %d) %d (order: %d)", i, tt.order, j, case2.order)69		}70	}71}72func TestUnsignedByteArrayCompare(t *testing.T) {73	s := ByteArrayStatistics{74		statistics: statistics{75			order: schema.SortUNSIGNED,76		},77	}78	s1ba := parquet.ByteArray("arrange")79	s2ba := parquet.ByteArray("arrangement")80	assert.True(t, s.less(s1ba, s2ba))81	// multi-byte utf-8 characters82	s1ba = parquet.ByteArray("braten")83	s2ba = parquet.ByteArray("bügeln")84	assert.True(t, s.less(s1ba, s2ba))85	s1ba = parquet.ByteArray("ünk123456") // ü = 25286	s2ba = parquet.ByteArray("ănk123456") // ă = 25987	assert.True(t, s.less(s1ba, s2ba))88}89func TestSignedCompareFLBA(t *testing.T) {90	s := FixedLenByteArrayStatistics{91		statistics: statistics{order: schema.SortSIGNED},92	}93	values := []parquet.FixedLenByteArray{94		[]byte{0x80, 0, 0, 0},95		[]byte{0xFF, 0xFF, 0x01, 0},96		[]byte{0xFF, 0xFF, 0x80, 0},97		[]byte{0xFF, 0xFF, 0xFF, 0x80},98		[]byte{0xFF, 0xFF, 0xFF, 0xFF},99		[]byte{0, 0, 0x01, 0x01},100		[]byte{0, 0x01, 0x01, 0},101		[]byte{0x01, 0x01, 0, 0},102	}103	for i, v := range values {104		assert.Falsef(t, s.less(v, v), "%d", i)105		for j, v2 := range values[i+1:] {106			assert.Truef(t, s.less(v, v2), "%d %d", i, j)107			assert.Falsef(t, s.less(v2, v), "%d %d", j, i)108		}109	}110}111func TestUnsignedCompareFLBA(t *testing.T) {112	s := FixedLenByteArrayStatistics{113		statistics: statistics{order: schema.SortUNSIGNED},114	}115	s1flba := parquet.FixedLenByteArray("Anti123456")116	s2flba := parquet.FixedLenByteArray("Bunkd123456")117	assert.True(t, s.less(s1flba, s2flba))118	s1flba = parquet.FixedLenByteArray("Bunk123456")119	s2flba = parquet.FixedLenByteArray("Bünk123456")120	assert.True(t, s.less(s1flba, s2flba))121}122func TestSignedCompareInt96(t *testing.T) {123	s := Int96Statistics{124		statistics: statistics{order: schema.SortSIGNED},125	}126	val := -14127	var (128		a   = parquet.NewInt96([3]uint32{1, 41, 14})129		b   = parquet.NewInt96([3]uint32{1, 41, 42})130		aa  = parquet.NewInt96([3]uint32{1, 41, 14})131		bb  = parquet.NewInt96([3]uint32{1, 41, 14})132		aaa = parquet.NewInt96([3]uint32{1, 41, uint32(val)})133		bbb = parquet.NewInt96([3]uint32{1, 41, 42})134	)135	assert.True(t, s.less(a, b))136	assert.True(t, !s.less(aa, bb) && !s.less(bb, aa))137	assert.True(t, s.less(aaa, bbb))138}139func TestUnsignedCompareInt96(t *testing.T) {140	s := Int96Statistics{141		statistics: statistics{order: schema.SortUNSIGNED},142	}143	valb := -41144	valbb := -14145	var (146		a   = parquet.NewInt96([3]uint32{1, 41, 14})147		b   = parquet.NewInt96([3]uint32{1, uint32(valb), 42})148		aa  = parquet.NewInt96([3]uint32{1, 41, 14})149		bb  = parquet.NewInt96([3]uint32{1, 41, uint32(valbb)})150		aaa parquet.Int96151		bbb parquet.Int96152	)153	assert.True(t, s.less(a, b))154	assert.True(t, s.less(aa, bb))155	binary.LittleEndian.PutUint32(aaa[8:], 2451545) // 2000-01-01156	binary.LittleEndian.PutUint32(bbb[8:], 2451546) // 2000-01-02157	// 12 hours + 34 minutes + 56 seconds158	aaa.SetNanoSeconds(45296000000000)159	// 12 hours + 34 minutes + 50 seconds160	bbb.SetNanoSeconds(45290000000000)161	assert.True(t, s.less(aaa, bbb))162	binary.LittleEndian.PutUint32(aaa[8:], 2451545) // 2000-01-01163	binary.LittleEndian.PutUint32(bbb[8:], 2451545) // 2000-01-01164	// 11 hours + 34 minutes + 56 seconds165	aaa.SetNanoSeconds(41696000000000)166	// 12 hours + 34 minutes + 50 seconds167	bbb.SetNanoSeconds(45290000000000)168	assert.True(t, s.less(aaa, bbb))169	binary.LittleEndian.PutUint32(aaa[8:], 2451545) // 2000-01-01170	binary.LittleEndian.PutUint32(bbb[8:], 2451545) // 2000-01-01171	// 12 hours + 34 minutes + 55 seconds172	aaa.SetNanoSeconds(45295000000000)173	// 12 hours + 34 minutes + 56 seconds174	bbb.SetNanoSeconds(45296000000000)175	assert.True(t, s.less(aaa, bbb))176}177func TestCompareSignedInt64(t *testing.T) {178	var (179		a   int64 = 1180		b   int64 = 4181		aa  int64 = 1182		bb  int64 = 1183		aaa int64 = -1184		bbb int64 = 1185	)186	n := schema.NewInt64Node("signedint64", parquet.Repetitions.Required, -1)187	descr := schema.NewColumn(n, 0, 0)188	s := NewStatistics(descr, nil).(*Int64Statistics)189	assert.True(t, s.less(a, b))190	assert.True(t, !s.less(aa, bb) && !s.less(bb, aa))191	assert.True(t, s.less(aaa, bbb))192}193func TestCompareUnsignedInt64(t *testing.T) {194	var (195		a   int64 = 1196		b   int64 = 4197		aa  int64 = 1198		bb  int64 = 1199		aaa int64 = 1200		bbb int64 = -1201	)202	n, err := schema.NewPrimitiveNodeConverted("unsigned int64", parquet.Repetitions.Required, parquet.Types.Int64, schema.ConvertedTypes.Uint64, 0, 0, 0, 0)203	require.NoError(t, err)204	descr := schema.NewColumn(n, 0, 0)205	assert.Equal(t, schema.SortUNSIGNED, descr.SortOrder())206	s := NewStatistics(descr, nil).(*Int64Statistics)207	assert.True(t, s.less(a, b))208	assert.True(t, !s.less(aa, bb) && !s.less(bb, aa))209	assert.True(t, s.less(aaa, bbb))210}211func TestCompareUnsignedInt32(t *testing.T) {212	var (213		a   int32 = 1214		b   int32 = 4215		aa  int32 = 1216		bb  int32 = 1217		aaa int32 = 1218		bbb int32 = -1219	)220	n, err := schema.NewPrimitiveNodeConverted("unsigned int32", parquet.Repetitions.Required, parquet.Types.Int32, schema.ConvertedTypes.Uint32, 0, 0, 0, 0)221	require.NoError(t, err)222	descr := schema.NewColumn(n, 0, 0)223	assert.Equal(t, schema.SortUNSIGNED, descr.SortOrder())224	s := NewStatistics(descr, nil).(*Int32Statistics)225	assert.True(t, s.less(a, b))226	assert.True(t, !s.less(aa, bb) && !s.less(bb, aa))227	assert.True(t, s.less(aaa, bbb))228}...

...22		panic(err)23	}24	return bytes25}26func sortForTest(inputData []val, lessFunc extsort.CompareLessFunc) error {27	// make array of all data in chan28	inputChan := make(chan extsort.SortType, 2)29	go func() {30		for _, d := range inputData {31			inputChan <- d32		}33		close(inputChan)34	}()35	config := extsort.DefaultConfig()36	config.ChunkSize = len(inputData)/20 + 10037	sort, outChan, errChan := extsort.New(inputChan, fromBytesForTest, lessFunc, config)38	sort.Sort(context.Background())39	i := 040	for rec := range outChan {41		inputData[i] = rec.(val)42		i++43	}44	if err := <-errChan; err != nil {45		return err46	}47	return nil48}49type val struct {50	Key, Order int51}52func makeTestArray(size int) []val {53	a := make([]val, size)54	for i := 0; i < size; i++ {55		a[i] = val{i & 0xeeeeee, i}56	}57	return a58}59func IsSorted(a []val, lessThan extsort.CompareLessFunc) bool {60	len := len(a)61	if len < 2 {62		return true63	}64	prev := a[0]65	for i := 1; i < len; i++ {66		if lessThan(a[i], prev) {67			return false68		}69		prev = a[i]70	}71	return true72}73func TestIsSorted(t *testing.T) {74	a := make([]val, 5)75	a[0] = val{3, 1}76	a[1] = val{1, 5}77	a[2] = val{2, 3}78	a[3] = val{3, 4}79	a[4] = val{4, 5}80	if IsSorted(a, OrderLessThan) {81		t.Error("Sorted")82	}83}84// use this comparator for sorting85func KeyLessThan(a, b extsort.SortType) bool {86	return a.(val).Key < b.(val).Key87}88// use this comparator to validate sorted data (and prove its stable)89func KeyOrderLessThan(ar, br extsort.SortType) bool {90	a := ar.(val)91	b := br.(val)92	if a.Key < b.Key {93		return true94	} else if a.Key == b.Key {95		return a.Order < b.Order96	}97	return false98}99// use this comparator to restore the original order of elements (by sorting on order field)100func OrderLessThan(a, b extsort.SortType) bool {101	return a.(val).Order < b.(val).Order102}103func Test50(t *testing.T) {104	a := makeTestArray(50)105	if IsSorted(a, KeyLessThan) {106		t.Error("sorted before starting")107	}108	err := sortForTest(a, KeyLessThan)109	if err != nil {110		t.Fatalf("sort: %v", err)111	}112	if !IsSorted(a, KeyLessThan) {113		t.Error("not sorted")114	}115}116func TestSmoke(t *testing.T) {117	a := make([]val, 3)118	a[0] = val{3, 0}119	a[1] = val{1, 1}120	a[2] = val{2, 2}121	err := sortForTest(a, KeyLessThan)122	if err != nil {123		t.Fatalf("sort: %v", err)124	}125	if !IsSorted(a, KeyLessThan) {126		t.Error("not sorted")127	}128}129func TestSmokeStability(t *testing.T) {130	a := make([]val, 3)131	a[0] = val{3, 0}132	a[1] = val{2, 1}133	a[2] = val{2, 2}134	err := sortForTest(a, KeyOrderLessThan)135	if err != nil {136		t.Fatalf("sort: %v", err)137	}138	if !IsSorted(a, KeyOrderLessThan) {139		t.Error("not sorted")140	}141}142func Test1K(t *testing.T) {143	a := makeTestArray(1024)144	err := sortForTest(a, KeyOrderLessThan)145	if err != nil {146		t.Fatalf("sort: %v", err)147	}148	if !IsSorted(a, KeyOrderLessThan) {149		t.Error("not sorted")150	}151}152func Test1M(t *testing.T) {153	a := makeTestArray(1024 * 1024)154	err := sortForTest(a, KeyOrderLessThan)155	if err != nil {156		t.Fatalf("sort: %v", err)157	}158	if !IsSorted(a, KeyOrderLessThan) {159		t.Error("not sorted")160	}161}162func makeRandomArray(size int) []val {163	a := make([]val, size)164	for i := 0; i < size; i++ {165		a[i] = val{rand.Intn(100), i}166	}167	return a168}169func Equals(a, b val) bool {170	return a.Key == b.Key && a.Order == b.Order171}172func TestRandom1M(t *testing.T) {173	size := 1024 * 1024174	a := makeRandomArray(size)175	b := make([]val, size)176	copy(b, a)177	err := sortForTest(a, KeyLessThan)178	if err != nil {179		t.Fatalf("sort: %v", err)180	}181	if !IsSorted(a, KeyLessThan) {182		t.Error("not sorted")183	}184	// sort by order185	err = sortForTest(a, OrderLessThan)186	if err != nil {187		t.Fatalf("sort: %v", err)188	}189	for i := 0; i < len(b); i++ {190		if !Equals(b[i], a[i]) {191			t.Error("oops")192		}193	}194}...

...5	"context"6	"testing"7	"github.com/lanrat/extsort"8)9func sortForMockTest(inputData []val, lessFunc extsort.CompareLessFunc) error {10	// make array of all data in chan11	inputChan := make(chan extsort.SortType, 2)12	go func() {13		for _, d := range inputData {14			inputChan <- d15		}16		close(inputChan)17	}()18	config := extsort.DefaultConfig()19	config.ChunkSize = len(inputData)/20 + 10020	sort, outChan, errChan := extsort.NewMock(inputChan, fromBytesForTest, lessFunc, config, 0)21	sort.Sort(context.Background())22	i := 023	for rec := range outChan {24		inputData[i] = rec.(val)25		i++26	}27	if err := <-errChan; err != nil {28		return err29	}30	return nil31}32func TestMock50(t *testing.T) {33	a := makeTestArray(50)34	if IsSorted(a, KeyLessThan) {35		t.Error("sorted before starting")36	}37	err := sortForMockTest(a, KeyLessThan)38	if err != nil {39		t.Fatalf("sort: %v", err)40	}41	if !IsSorted(a, KeyLessThan) {42		t.Error("not sorted")43	}44}45func TestMockSmoke(t *testing.T) {46	a := make([]val, 3)47	a[0] = val{3, 0}48	a[1] = val{1, 1}49	a[2] = val{2, 2}50	err := sortForMockTest(a, KeyLessThan)51	if err != nil {52		t.Fatalf("sort: %v", err)53	}54	if !IsSorted(a, KeyLessThan) {55		t.Error("not sorted")56	}57}58func TestMockSmokeStability(t *testing.T) {59	a := make([]val, 3)60	a[0] = val{3, 0}61	a[1] = val{2, 1}62	a[2] = val{2, 2}63	err := sortForMockTest(a, KeyOrderLessThan)64	if err != nil {65		t.Fatalf("sort: %v", err)66	}67	if !IsSorted(a, KeyOrderLessThan) {68		t.Error("not sorted")69	}70}71func TestMock1K(t *testing.T) {72	a := makeTestArray(1024)73	err := sortForMockTest(a, KeyOrderLessThan)74	if err != nil {75		t.Fatalf("sort: %v", err)76	}77	if !IsSorted(a, KeyOrderLessThan) {78		t.Error("not sorted")79	}80}81func TestMock1M(t *testing.T) {82	a := makeTestArray(1024 * 1024)83	err := sortForMockTest(a, KeyOrderLessThan)84	if err != nil {85		t.Fatalf("sort: %v", err)86	}87	if !IsSorted(a, KeyOrderLessThan) {88		t.Error("not sorted")89	}90}91func TestMockRandom1M(t *testing.T) {92	size := 1024 * 102493	a := makeRandomArray(size)94	b := make([]val, size)95	copy(b, a)96	err := sortForMockTest(a, KeyLessThan)97	if err != nil {98		t.Fatalf("sort: %v", err)99	}100	if !IsSorted(a, KeyLessThan) {101		t.Error("not sorted")102	}103	// sort by order104	err = sortForTest(a, OrderLessThan)105	if err != nil {106		t.Fatalf("sort: %v", err)107	}108	for i := 0; i < len(b); i++ {109		if !Equals(b[i], a[i]) {110			t.Error("oops")111		}112	}113}...

11.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:2order does not implement sort.Interface (missing Len method)31.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:4order does not implement sort.Interface (missing Less method)51.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:6order does not implement sort.Interface (missing Swap method)71.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:8order does not implement sort.Interface (missing Len method)91.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:10order does not implement sort.Interface (missing Less method)111.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:12order does not implement sort.Interface (missing Swap method)131.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:14order does not implement sort.Interface (missing Len method)151.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:16order does not implement sort.Interface (missing Less method)171.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:18order does not implement sort.Interface (missing Swap method)191.go:4: cannot use order literal (type order) as type sort.Interface in argument to sort.Sort:20order does not implement sort.Interface (missing Len method)211.go:4: cannot use order literal (type order)

1import (2type order struct {3}4func (o byId) Len() int {5	return len(o)6}7func (o byId) Less(i, j int) bool {8}9func (o byId) Swap(i, j int) {10}11func main() {12	orders := []order{13		{ordId: 456, customerId: 56},14		{ordId: 768, customerId: 19},15		{ordId: 234, customerId: 34},16		{ordId: 890, customerId: 12},17		{ordId: 123, customerId: 23},18	}19	sort.Sort(byId(orders))20	fmt.Println(orders)21}22[{123 23} {234 34} {456 56} {768 19} {890 12}]23import (24type customer struct {25}26func (c byName) Len() int {27	return len(c)28}29func (c byName) Less(i, j int) bool {30}31func (c byName) Swap(i, j int) {32}33func main() {34	customers := []customer{35		{custId: 56, customerName: "James"},36		{custId: 19, customerName: "Andy"},37		{custId: 34, customerName: "Peter"},38		{custId: 12, customerName: "Mark"},39		{custId: 23, customerName: "Ricky"},40	}41	sort.Sort(byName(customers))42	fmt.Println(customers)43}44[{12 Mark} {19 Andy} {56 James} {23 Ricky} {34 Peter}]45import (

1import (2type order struct {3}4func (o byId) Len() int {5	return len(o)6}7func (o byId) Less(i, j int) bool {8}9func (o byId) Swap(i, j int) {10}11func main() {12	ords := byId{13		{3, 9},14		{1, 2},15		{2, 4},16		{4, 8},17	}18	sort.Sort(ords)19	fmt.Println(ords)20}21[{1 2} {2 4} {3 9} {4 8}]

1import "fmt"2type Order struct {3}4func (o Order) Less(other Order) bool {5}6func main() {7    o1 := Order{price: 100}8    o2 := Order{price: 200}9    fmt.Println(o1.Less(o2))10}

1import (2func main() {3	strs := []string{"c", "a", "b"}4	sort.Strings(strs)5	fmt.Println("Strings:", strs)6	ints := []int{7, 2, 4}7	sort.Ints(ints)8	fmt.Println("Ints:   ", ints)9	s := []float64{7.0, 2.0, 4.0}10	sort.Float64s(s)11	fmt.Println("Floats: ", s)12	sorted := sort.Float64sAreSorted(s)13	fmt.Println("Sorted: ", sorted)14}15import (16type Person struct {17}18func (p ByName) Len() int {19	return len(p)20}21func (p ByName) Less(i, j int) bool {22}23func (p ByName) Swap(i, j int) {24}25func main() {26	kids := []Person{27		{"Jill", 9},28		{"Jack", 10},29	}30	sort.Sort(ByName(kids))31	fmt.Println(kids)32}33[{Jack 10} {Jill 9}]34import (

1import (2type Order struct {3}4func (o Order) String() string {5    return fmt.Sprintf("%d %.2f", o.Id, o.Price)6}7func (o Order) Less(other Order) bool {8}9func main() {10    orders := []Order{11        {1, 100},12        {2, 50},13        {3, 10},14    }15    fmt.Println(orders)16    sort.Sort(OrderSlice(orders))17    fmt.Println(orders)18}19import (20type Order struct {21}22func (o Order) String() string {23    return fmt.Sprintf("%d %.2f", o.Id, o.Price)24}25func (o Order) Less(other Order) bool {26}27func main() {28    orders := []Order{29        {1, 100},30        {2, 50},31        {3, 10},32    }33    fmt.Println(orders)34    sort.Sort(OrderSlice(orders))35    fmt.Println(orders)36}37import (38type Order struct {39}40func (o Order) String() string {41    return fmt.Sprintf("%d %.2f", o.Id, o.Price)42}43func (o Order) Less(other Order) bool {44}45func main() {46    orders := []Order{47        {1, 100},48        {2, 50},49        {3, 10},50    }

1import (2type Order struct {3}4func (o Order) Less(i interface{}) bool {5	return o.Price < i.(Order).Price6}7func (o Order) Greater(i interface{}) bool {8	return o.Price > i.(Order).Price9}10func main() {11	orders := []Order{12		{Price: 100},13		{Price: 10},14		{Price: 1000},15		{Price: 500},16		{Price: 10000},17		{Price: 200},18	}19	fmt.Println("Before sorting")20	for _, o := range orders {21		fmt.Println(o)22	}23	sort.Sort(sort.Reverse(sortableOrders(orders)))24	fmt.Println("After sorting")25	for _, o := range orders {26		fmt.Println(o)27	}28}29{100}30{10}31{1000}32{500}33{10000}34{200}35{10000}36{1000}37{500}38{200}39{100}40{10}

1import "fmt"2func main() {3    fmt.Println("Hello, World!")4}5import "fmt"6func init() {7    fmt.Println("init function is called")8}9func main() {10    fmt.Println("main function is called")11}12import "package path"13import "fmt"14func main() {15    fmt.Println("Hello, World!")16}17To import a single package, use the following syntax:18import "package path"19import "fmt"20func main() {21    fmt.Println("Hello, World!")22}

1import (2func main() {3	order := Order{4	}5	order1 := Order{6	}7	order2 := Order{8	}9	order3 := Order{10	}11	order4 := Order{12	}13	order5 := Order{14	}15	order6 := Order{16	}17	order7 := Order{18	}19	order8 := Order{20	}21	order9 := Order{22	}23	order10 := Order{24	}25	order11 := Order{26	}27	order12 := Order{28	}29	order13 := Order{30	}31	order14 := Order{32	}