apache
diff --git a/‎CHANGELOG.md‎
Lines changed: 4 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎cassandra_test.go‎
Lines changed: 95 additions & 51 deletions b/‎cassandra_test.go‎
Lines changed: 95 additions & 51 deletions
diff --git a/‎common_test.go‎
Lines changed: 4 additions & 4 deletions b/‎common_test.go‎
Lines changed: 4 additions & 4 deletions
@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Externally-defined type registration (CASSGO-43)
+
 ### Changed
 
 - Don't restrict server authenticator unless PasswordAuthentictor.AllowedAuthenticators is provided (CASSGO-19)
@@ -33,6 +35,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Standardized spelling of datacenter (CASSGO-35)
 
+- inet columns are now unmarshalled as net.IP when using MapScan or SliceMap (CASSGO-43)
+
 ### Fixed
 - Cassandra version unmarshal fix (CASSGO-49)
 
 
@@ -560,7 +560,7 @@ func TestDurationType(t *testing.T) {
 	defer session.Close()
 
 	if session.cfg.ProtoVersion < 5 {
-		t.Skip("Duration type is not supported. Please use protocol version >= 4 and cassandra version >= 3.11")
+		t.Skip("Duration type is not supported. Please use protocol version > 4")
 	}
 
 	if err := createTable(session, `CREATE TABLE gocql_test.duration_table (
@@ -983,7 +983,7 @@ func TestMapScan(t *testing.T) {
 	}
 	assertEqual(t, "fullname", "Ada Lovelace", row["fullname"])
 	assertEqual(t, "age", 30, row["age"])
-	assertEqual(t, "address", "10.0.0.2", row["address"])
+	assertDeepEqual(t, "address", net.ParseIP("10.0.0.2").To4(), row["address"])
 	assertDeepEqual(t, "data", []byte(`{"foo": "bar"}`), row["data"])
 
 	// Second iteration using a new map
@@ -993,7 +993,7 @@ func TestMapScan(t *testing.T) {
 	}
 	assertEqual(t, "fullname", "Grace Hopper", row["fullname"])
 	assertEqual(t, "age", 31, row["age"])
-	assertEqual(t, "address", "10.0.0.1", row["address"])
+	assertDeepEqual(t, "address", net.ParseIP("10.0.0.1").To4(), row["address"])
 	assertDeepEqual(t, "data", []byte(nil), row["data"])
 }
 
@@ -1040,7 +1040,7 @@ func TestSliceMap(t *testing.T) {
 	m["testset"] = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
 	m["testmap"] = map[string]string{"field1": "val1", "field2": "val2", "field3": "val3"}
 	m["testvarint"] = bigInt
-	m["testinet"] = "213.212.2.19"
+	m["testinet"] = net.ParseIP("213.212.2.19").To4()
 	sliceMap := []map[string]interface{}{m}
 	if err := session.Query(`INSERT INTO slice_map_table (testuuid, testtimestamp, testvarchar, testbigint, testblob, testbool, testfloat, testdouble, testint, testdecimal, testlist, testset, testmap, testvarint, testinet) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 		m["testuuid"], m["testtimestamp"], m["testvarchar"], m["testbigint"], m["testblob"], m["testbool"], m["testfloat"], m["testdouble"], m["testint"], m["testdecimal"], m["testlist"], m["testset"], m["testmap"], m["testvarint"], m["testinet"]).Exec(); err != nil {
@@ -1072,51 +1072,105 @@ func TestSliceMap(t *testing.T) {
 }
 func matchSliceMap(t *testing.T, sliceMap []map[string]interface{}, testMap map[string]interface{}) {
 	if sliceMap[0]["testuuid"] != testMap["testuuid"] {
-		t.Fatal("returned testuuid did not match")
+		t.Fatalf("returned testuuid %#v did not match %#v", sliceMap[0]["testuuid"], testMap["testuuid"])
 	}
 	if sliceMap[0]["testtimestamp"] != testMap["testtimestamp"] {
-		t.Fatal("returned testtimestamp did not match")
+		t.Fatalf("returned testtimestamp %#v did not match %#v", sliceMap[0]["testtimestamp"], testMap["testtimestamp"])
 	}
 	if sliceMap[0]["testvarchar"] != testMap["testvarchar"] {
-		t.Fatal("returned testvarchar did not match")
+		t.Fatalf("returned testvarchar %#v did not match %#v", sliceMap[0]["testvarchar"], testMap["testvarchar"])
 	}
 	if sliceMap[0]["testbigint"] != testMap["testbigint"] {
-		t.Fatal("returned testbigint did not match")
+		t.Fatalf("returned testbigint %#v did not match %#v", sliceMap[0]["testbigint"], testMap["testbigint"])
 	}
 	if !reflect.DeepEqual(sliceMap[0]["testblob"], testMap["testblob"]) {
-		t.Fatal("returned testblob did not match")
+		t.Fatalf("returned testblob %#v did not match %#v", sliceMap[0]["testblob"], testMap["testblob"])
 	}
 	if sliceMap[0]["testbool"] != testMap["testbool"] {
-		t.Fatal("returned testbool did not match")
+		t.Fatalf("returned testbool %#v did not match %#v", sliceMap[0]["testbool"], testMap["testbool"])
 	}
 	if sliceMap[0]["testfloat"] != testMap["testfloat"] {
-		t.Fatal("returned testfloat did not match")
+		t.Fatalf("returned testfloat %#v did not match %#v", sliceMap[0]["testfloat"], testMap["testfloat"])
 	}
 	if sliceMap[0]["testdouble"] != testMap["testdouble"] {
-		t.Fatal("returned testdouble did not match")
+		t.Fatalf("returned testdouble %#v did not match %#v", sliceMap[0]["testdouble"], testMap["testdouble"])
 	}
-	if sliceMap[0]["testinet"] != testMap["testinet"] {
-		t.Fatal("returned testinet did not match")
+	if !reflect.DeepEqual(sliceMap[0]["testinet"], testMap["testinet"]) {
+		t.Fatalf("returned testinet %#v did not match %#v", sliceMap[0]["testinet"], testMap["testinet"])
 	}
 
 	expectedDecimal := sliceMap[0]["testdecimal"].(*inf.Dec)
 	returnedDecimal := testMap["testdecimal"].(*inf.Dec)
 
 	if expectedDecimal.Cmp(returnedDecimal) != 0 {
-		t.Fatal("returned testdecimal did not match")
+		t.Fatalf("returned testdecimal %#v did not match %#v", sliceMap[0]["testdecimal"], testMap["testdecimal"])
 	}
 
 	if !reflect.DeepEqual(sliceMap[0]["testlist"], testMap["testlist"]) {
-		t.Fatal("returned testlist did not match")
+		t.Fatalf("returned testlist %#v did not match %#v", sliceMap[0]["testlist"], testMap["testlist"])
 	}
 	if !reflect.DeepEqual(sliceMap[0]["testset"], testMap["testset"]) {
-		t.Fatal("returned testset did not match")
+		t.Fatalf("returned testset %#v did not match %#v", sliceMap[0]["testset"], testMap["testset"])
 	}
 	if !reflect.DeepEqual(sliceMap[0]["testmap"], testMap["testmap"]) {
-		t.Fatal("returned testmap did not match")
+		t.Fatalf("returned testmap %#v did not match %#v", sliceMap[0]["testmap"], testMap["testmap"])
 	}
 	if sliceMap[0]["testint"] != testMap["testint"] {
-		t.Fatal("returned testint did not match")
+		t.Fatalf("returned testint %#v did not match %#v", sliceMap[0]["testint"], testMap["testint"])
+	}
+}
+
+func TestSliceMap_CopySlices(t *testing.T) {
+	session := createSession(t)
+	defer session.Close()
+	if err := createTable(session, `CREATE TABLE gocql_test.slice_map_copy_table (
+			t text,
+			u timeuuid,
+			l list<text>,
+			PRIMARY KEY (t, u)
+		)`); err != nil {
+		t.Fatal("create table:", err)
+	}
+
+	err := session.Query(
+		`INSERT INTO slice_map_copy_table (t, u, l) VALUES ('test', ?, ?)`,
+		TimeUUID(), []string{"1", "2"},
+	).Exec()
+	if err != nil {
+		t.Fatal("insert:", err)
+	}
+
+	err = session.Query(
+		`INSERT INTO slice_map_copy_table (t, u, l) VALUES ('test', ?, ?)`,
+		TimeUUID(), []string{"3", "4"},
+	).Exec()
+	if err != nil {
+		t.Fatal("insert:", err)
+	}
+
+	err = session.Query(
+		`INSERT INTO slice_map_copy_table (t, u, l) VALUES ('test', ?, ?)`,
+		TimeUUID(), []string{"5", "6"},
+	).Exec()
+	if err != nil {
+		t.Fatal("insert:", err)
+	}
+
+	if returned, retErr := session.Query(`SELECT * FROM slice_map_copy_table WHERE t = 'test'`).Iter().SliceMap(); retErr != nil {
+		t.Fatal("select:", retErr)
+	} else {
+		if len(returned) != 3 {
+			t.Fatal("expected 3 rows, got", len(returned))
+		}
+		if !reflect.DeepEqual(returned[0]["l"], []string{"1", "2"}) {
+			t.Fatal("expected [1, 2], got", returned[0]["l"])
+		}
+		if !reflect.DeepEqual(returned[1]["l"], []string{"3", "4"}) {
+			t.Fatal("expected [3, 4], got", returned[1]["l"])
+		}
+		if !reflect.DeepEqual(returned[2]["l"], []string{"5", "6"}) {
+			t.Fatal("expected [5, 6], got", returned[2]["l"])
+		}
 	}
 }
 
@@ -1193,7 +1247,7 @@ func TestSmallInt(t *testing.T) {
 		t.Fatal("select:", retErr)
 	} else {
 		if sliceMap[0]["testsmallint"] != returned[0]["testsmallint"] {
-			t.Fatal("returned testsmallint did not match")
+			t.Fatalf("returned testsmallint %#v did not match %#v", returned[0]["testsmallint"], sliceMap[0]["testsmallint"])
 		}
 	}
 }
@@ -1513,9 +1567,7 @@ func injectInvalidPreparedStatement(t *testing.T, session *Session, table string
 						Keyspace: "gocql_test",
 						Table:    table,
 						Name:     "foo",
-						TypeInfo: NativeType{
-							typ: TypeVarchar,
-						},
+						TypeInfo: TypeVarchar,
 					},
 				},
 			},
@@ -2418,15 +2470,13 @@ func TestAggregateMetadata(t *testing.T) {
 	expectedAggregrate := AggregateMetadata{
 		Keyspace:      "gocql_test",
 		Name:          "average",
-		ArgumentTypes: []TypeInfo{NativeType{typ: TypeInt}},
+		ArgumentTypes: []TypeInfo{TypeInt},
 		InitCond:      "(0, 0)",
-		ReturnType:    NativeType{typ: TypeDouble},
+		ReturnType:    TypeDouble,
 		StateType: TupleTypeInfo{
-			NativeType: NativeType{typ: TypeTuple},
-
 			Elems: []TypeInfo{
-				NativeType{typ: TypeInt},
-				NativeType{typ: TypeBigInt},
+				TypeInt,
+				TypeBigInt,
 			},
 		},
 		stateFunc: "avgstate",
@@ -2439,11 +2489,11 @@ func TestAggregateMetadata(t *testing.T) {
 	}
 
 	if !reflect.DeepEqual(aggregates[0], expectedAggregrate) {
-		t.Fatalf("aggregate 'average' is %+v, but expected %+v", aggregates[0], expectedAggregrate)
+		t.Fatalf("aggregate 'average' is %#v, but expected %#v", aggregates[0], expectedAggregrate)
 	}
 	expectedAggregrate.Name = "average2"
 	if !reflect.DeepEqual(aggregates[1], expectedAggregrate) {
-		t.Fatalf("aggregate 'average2' is %+v, but expected %+v", aggregates[1], expectedAggregrate)
+		t.Fatalf("aggregate 'average2' is %#v, but expected %#v", aggregates[1], expectedAggregrate)
 	}
 }
 
@@ -2471,22 +2521,18 @@ func TestFunctionMetadata(t *testing.T) {
 		Name:     "avgstate",
 		ArgumentTypes: []TypeInfo{
 			TupleTypeInfo{
-				NativeType: NativeType{typ: TypeTuple},
-
 				Elems: []TypeInfo{
-					NativeType{typ: TypeInt},
-					NativeType{typ: TypeBigInt},
+					TypeInt,
+					TypeBigInt,
 				},
 			},
-			NativeType{typ: TypeInt},
+			TypeInt,
 		},
 		ArgumentNames: []string{"state", "val"},
 		ReturnType: TupleTypeInfo{
-			NativeType: NativeType{typ: TypeTuple},
-
 			Elems: []TypeInfo{
-				NativeType{typ: TypeInt},
-				NativeType{typ: TypeBigInt},
+				TypeInt,
+				TypeBigInt,
 			},
 		},
 		CalledOnNullInput: true,
@@ -2503,22 +2549,20 @@ func TestFunctionMetadata(t *testing.T) {
 		Name:     "avgfinal",
 		ArgumentTypes: []TypeInfo{
 			TupleTypeInfo{
-				NativeType: NativeType{typ: TypeTuple},
-
 				Elems: []TypeInfo{
-					NativeType{typ: TypeInt},
-					NativeType{typ: TypeBigInt},
+					TypeInt,
+					TypeBigInt,
 				},
 			},
 		},
 		ArgumentNames:     []string{"state"},
-		ReturnType:        NativeType{typ: TypeDouble},
+		ReturnType:        TypeDouble,
 		CalledOnNullInput: true,
 		Language:          "java",
 		Body:              finalStateBody,
 	}
 	if !reflect.DeepEqual(avgFinal, expectedAvgFinal) {
-		t.Fatalf("function is %+v, but expected %+v", avgFinal, expectedAvgFinal)
+		t.Fatalf("function is %#v, but expected %#v", avgFinal, expectedAvgFinal)
 	}
 }
 
@@ -2621,14 +2665,14 @@ func TestKeyspaceMetadata(t *testing.T) {
 		Name:       "basicview",
 		FieldNames: []string{"birthday", "nationality", "weight", "height"},
 		FieldTypes: []TypeInfo{
-			NativeType{typ: TypeTimestamp},
-			NativeType{typ: textType},
-			NativeType{typ: textType},
-			NativeType{typ: textType},
+			TypeTimestamp,
+			textType,
+			textType,
+			textType,
 		},
 	}
 	if !reflect.DeepEqual(*keyspaceMetadata.UserTypes["basicview"], expectedType) {
-		t.Fatalf("type is %+v, but expected %+v", keyspaceMetadata.UserTypes["basicview"], expectedType)
+		t.Fatalf("type is %#v, but expected %#v", keyspaceMetadata.UserTypes["basicview"], expectedType)
 	}
 	if flagCassVersion.Major >= 3 {
 		materializedView, found := keyspaceMetadata.MaterializedViews["view_view"]
 
@@ -236,7 +236,7 @@ func createFunctions(t *testing.T, session *Session) {
 		CALLED ON NULL INPUT
 		RETURNS double
 		LANGUAGE java AS
-		$$double r = 0; if (state.getInt(0) == 0) return null; r = state.getLong(1); r/= state.getInt(0); return Double.valueOf(r);$$ 
+		$$double r = 0; if (state.getInt(0) == 0) return null; r = state.getLong(1); r/= state.getInt(0); return Double.valueOf(r);$$
 	`).Exec(); err != nil {
 		t.Fatalf("failed to create function with err: %v", err)
 	}
@@ -280,20 +280,20 @@ func assertTrue(t *testing.T, description string, value bool) {
 func assertEqual(t *testing.T, description string, expected, actual interface{}) {
 	t.Helper()
 	if expected != actual {
-		t.Fatalf("expected %s to be (%+v) but was (%+v) instead", description, expected, actual)
+		t.Fatalf("expected %s to be (%#v) but was (%#v) instead", description, expected, actual)
 	}
 }
 
 func assertDeepEqual(t *testing.T, description string, expected, actual interface{}) {
 	t.Helper()
 	if !reflect.DeepEqual(expected, actual) {
-		t.Fatalf("expected %s to be (%+v) but was (%+v) instead", description, expected, actual)
+		t.Fatalf("expected %s to be (%#v) but was (%#v) instead", description, expected, actual)
 	}
 }
 
 func assertNil(t *testing.T, description string, actual interface{}) {
 	t.Helper()
 	if actual != nil {
-		t.Fatalf("expected %s to be (nil) but was (%+v) instead", description, actual)
+		t.Fatalf("expected %s to be (nil) but was (%#v) instead", description, actual)
 	}
 }
Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ func createFunctions(t testing.T, session Session) {`
`236`	`236`	`CALLED ON NULL INPUT`
`237`	`237`	`RETURNS double`
`238`	`238`	`LANGUAGE java AS`
`239`		`- $$double r = 0; if (state.getInt(0) == 0) return null; r = state.getLong(1); r/= state.getInt(0); return Double.valueOf(r);$$`
	`239`	`+ $$double r = 0; if (state.getInt(0) == 0) return null; r = state.getLong(1); r/= state.getInt(0); return Double.valueOf(r);$$`
`240`	`240`	`).Exec(); err != nil {
`241`	`241`	`t.Fatalf("failed to create function with err: %v", err)`
`242`	`242`	`}`
`@@ -280,20 +280,20 @@ func assertTrue(t *testing.T, description string, value bool) {`
`280`	`280`	`func assertEqual(t *testing.T, description string, expected, actual interface{}) {`
`281`	`281`	`t.Helper()`
`282`	`282`	`if expected != actual {`
`283`		`- t.Fatalf("expected %s to be (%+v) but was (%+v) instead", description, expected, actual)`
	`283`	`+ t.Fatalf("expected %s to be (%#v) but was (%#v) instead", description, expected, actual)`
`284`	`284`	`}`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`func assertDeepEqual(t *testing.T, description string, expected, actual interface{}) {`
`288`	`288`	`t.Helper()`
`289`	`289`	`if !reflect.DeepEqual(expected, actual) {`
`290`		`- t.Fatalf("expected %s to be (%+v) but was (%+v) instead", description, expected, actual)`
	`290`	`+ t.Fatalf("expected %s to be (%#v) but was (%#v) instead", description, expected, actual)`
`291`	`291`	`}`
`292`	`292`	`}`
`293`	`293`
`294`	`294`	`func assertNil(t *testing.T, description string, actual interface{}) {`
`295`	`295`	`t.Helper()`
`296`	`296`	`if actual != nil {`
`297`		`- t.Fatalf("expected %s to be (nil) but was (%+v) instead", description, actual)`
	`297`	`+ t.Fatalf("expected %s to be (nil) but was (%#v) instead", description, actual)`
`298`	`298`	`}`
`299`	`299`	`}`