wehub/dolthub--doltgresql
1
0
Fork 0
Code Issues Pull Requests Actions 1 Deployments Models Agent Notes Packages Projects Releases Wiki Activity

chore: import upstream snapshot with attribution

Browse Source
This commit is contained in:
wehub-resource-sync
2026-07-13 12:32:25 +08:00
commit e014feafe1
2285 changed files with 1131979 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
testing/generation/function_coverage/output/abs_test.go
+331
View File
@@ -0,0 +1,331 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Abs(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "abs",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT abs( 0::int2 ) ;",
Expected: []sql.Row{{int16(0)}},
},
{
Query: "SELECT abs( -1::int2 ) ;",
Expected: []sql.Row{{int16(1)}},
},
{
Query: "SELECT abs( 1::int2 ) ;",
Expected: []sql.Row{{int16(1)}},
},
{
Query: "SELECT abs( 2::int2 ) ;",
Expected: []sql.Row{{int16(2)}},
},
{
Query: "SELECT abs( -2::int2 ) ;",
Expected: []sql.Row{{int16(2)}},
},
{
Query: "SELECT abs( 5::int2 ) ;",
Expected: []sql.Row{{int16(5)}},
},
{
Query: "SELECT abs( 10::int2 ) ;",
Expected: []sql.Row{{int16(10)}},
},
{
Query: "SELECT abs( -10::int2 ) ;",
Expected: []sql.Row{{int16(10)}},
},
{
Query: "SELECT abs( 100::int2 ) ;",
Expected: []sql.Row{{int16(100)}},
},
{
Query: "SELECT abs( 2105::int2 ) ;",
Expected: []sql.Row{{int16(2105)}},
},
{
Query: "SELECT abs( 10000::int2 ) ;",
Expected: []sql.Row{{int16(10000)}},
},
{
Query: "SELECT abs( -11842::int2 ) ;",
Expected: []sql.Row{{int16(11842)}},
},
{
Query: "SELECT abs( 25252::int2 ) ;",
Expected: []sql.Row{{int16(25252)}},
},
{
Query: "SELECT abs( -32768::int2 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT abs( 32767::int2 ) ;",
Expected: []sql.Row{{int16(32767)}},
},
{
Query: "SELECT abs( 0::int4 ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT abs( -1::int4 ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT abs( 1::int4 ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT abs( 2::int4 ) ;",
Expected: []sql.Row{{int32(2)}},
},
{
Query: "SELECT abs( -2::int4 ) ;",
Expected: []sql.Row{{int32(2)}},
},
{
Query: "SELECT abs( 5::int4 ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT abs( 10::int4 ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT abs( -10::int4 ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT abs( 100::int4 ) ;",
Expected: []sql.Row{{int32(100)}},
},
{
Query: "SELECT abs( 21050::int4 ) ;",
Expected: []sql.Row{{int32(21050)}},
},
{
Query: "SELECT abs( 100000::int4 ) ;",
Expected: []sql.Row{{int32(100000)}},
},
{
Query: "SELECT abs( -1184280::int4 ) ;",
Expected: []sql.Row{{int32(1184280)}},
},
{
Query: "SELECT abs( 2525280::int4 ) ;",
Expected: []sql.Row{{int32(2525280)}},
},
{
Query: "SELECT abs( -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT abs( 2147483647::int4 ) ;",
Expected: []sql.Row{{int32(2147483647)}},
},
{
Query: "SELECT abs( 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT abs( -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT abs( 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT abs( 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT abs( -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT abs( 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT abs( 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT abs( -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT abs( 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT abs( 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT abs( 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT abs( -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT abs( 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT abs( -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT abs( 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
{
Query: "SELECT abs( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT abs( -1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT abs( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT abs( 2::float8 ) ;",
Expected: []sql.Row{{float64(2.000000)}},
},
{
Query: "SELECT abs( -2::float8 ) ;",
Expected: []sql.Row{{float64(2.000000)}},
},
{
Query: "SELECT abs( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(5.250000)}},
},
{
Query: "SELECT abs( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(10.870000)}},
},
{
Query: "SELECT abs( -10::float8 ) ;",
Expected: []sql.Row{{float64(10.000000)}},
},
{
Query: "SELECT abs( 100::float8 ) ;",
Expected: []sql.Row{{float64(100.000000)}},
},
{
Query: "SELECT abs( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(21050.480000)}},
},
{
Query: "SELECT abs( 100000::float8 ) ;",
Expected: []sql.Row{{float64(100000.000000)}},
},
{
Query: "SELECT abs( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(1184280.000000)}},
},
{
Query: "SELECT abs( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(2525280.279000)}},
},
{
Query: "SELECT abs( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(2147483648.000000)}},
},
{
Query: "SELECT abs( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(2147483647.590240)}},
},
{
Query: "SELECT abs( 0::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT abs( -1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT abs( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT abs( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT abs( -2::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT abs( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT abs( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT abs( -10::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT abs( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("1000")}},
},
{
Query: "SELECT abs( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("2105076")}},
},
{
Query: "SELECT abs( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("100000000.2345862323456346511423652312416532")}},
},
{
Query: "SELECT abs( -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("5184226581")}},
},
{
Query: "SELECT abs( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("8525267290")}},
},
{
Query: "SELECT abs( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775808")}},
},
{
Query: "SELECT abs( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775807")}},
},
},
},
})
}
testing/generation/function_coverage/output/acos_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Acos(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "acos",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT acos( 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT acos( -1::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT acos( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT acos( 2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( 5.25::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( 10.87::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( 100::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( 21050.48::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( 100000::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( 2525280.279::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acos( 2147483647.59024::float8 ) ;",
ExpectedErr: true,
},
},
},
})
}
testing/generation/function_coverage/output/acosd_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Acosd(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "acosd",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT acosd( 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT acosd( -1::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT acosd( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT acosd( 2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( 5.25::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( 10.87::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( 100::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( 21050.48::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( 100000::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( 2525280.279::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosd( 2147483647.59024::float8 ) ;",
ExpectedErr: true,
},
},
},
})
}
testing/generation/function_coverage/output/acosh_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Acosh(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "acosh",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT acosh( 0::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosh( -1::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosh( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT acosh( 2::float8 ) ;",
Expected: []sql.Row{{float64(1.316958)}},
},
{
Query: "SELECT acosh( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosh( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(2.342179)}},
},
{
Query: "SELECT acosh( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(3.077031)}},
},
{
Query: "SELECT acosh( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosh( 100::float8 ) ;",
Expected: []sql.Row{{float64(5.298292)}},
},
{
Query: "SELECT acosh( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(10.647826)}},
},
{
Query: "SELECT acosh( 100000::float8 ) ;",
Expected: []sql.Row{{float64(12.206073)}},
},
{
Query: "SELECT acosh( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosh( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(15.435010)}},
},
{
Query: "SELECT acosh( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT acosh( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(22.180710)}},
},
},
},
})
}
testing/generation/function_coverage/output/ascii_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Ascii(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "ascii",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT ascii( '' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT ascii( ' ' ) ;",
Expected: []sql.Row{{int32(32)}},
},
{
Query: "SELECT ascii( '0' ) ;",
Expected: []sql.Row{{int32(48)}},
},
{
Query: "SELECT ascii( '1' ) ;",
Expected: []sql.Row{{int32(49)}},
},
{
Query: "SELECT ascii( 'a' ) ;",
Expected: []sql.Row{{int32(97)}},
},
{
Query: "SELECT ascii( 'abc' ) ;",
Expected: []sql.Row{{int32(97)}},
},
{
Query: "SELECT ascii( '123' ) ;",
Expected: []sql.Row{{int32(49)}},
},
{
Query: "SELECT ascii( 'value' ) ;",
Expected: []sql.Row{{int32(118)}},
},
{
Query: "SELECT ascii( '12345' ) ;",
Expected: []sql.Row{{int32(49)}},
},
{
Query: "SELECT ascii( 'something' ) ;",
Expected: []sql.Row{{int32(115)}},
},
{
Query: "SELECT ascii( ' something' ) ;",
Expected: []sql.Row{{int32(32)}},
},
{
Query: "SELECT ascii( 'something ' ) ;",
Expected: []sql.Row{{int32(115)}},
},
{
Query: "SELECT ascii( '123456789' ) ;",
Expected: []sql.Row{{int32(49)}},
},
{
Query: "SELECT ascii( 'a group of words' ) ;",
Expected: []sql.Row{{int32(97)}},
},
{
Query: "SELECT ascii( '1234567890123456' ) ;",
Expected: []sql.Row{{int32(49)}},
},
},
},
})
}
testing/generation/function_coverage/output/asin_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Asin(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "asin",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT asin( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT asin( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT asin( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT asin( 2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( 5.25::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( 10.87::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( 100::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( 21050.48::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( 100000::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( 2525280.279::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asin( 2147483647.59024::float8 ) ;",
ExpectedErr: true,
},
},
},
})
}
testing/generation/function_coverage/output/asind_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Asind(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "asind",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT asind( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT asind( -1::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT asind( 1::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT asind( 2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( 5.25::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( 10.87::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( 100::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( 21050.48::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( 100000::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( 2525280.279::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT asind( 2147483647.59024::float8 ) ;",
ExpectedErr: true,
},
},
},
})
}
testing/generation/function_coverage/output/asinh_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Asinh(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "asinh",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT asinh( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT asinh( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.881374)}},
},
{
Query: "SELECT asinh( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.881374)}},
},
{
Query: "SELECT asinh( 2::float8 ) ;",
Expected: []sql.Row{{float64(1.443635)}},
},
{
Query: "SELECT asinh( -2::float8 ) ;",
Expected: []sql.Row{{float64(-1.443635)}},
},
{
Query: "SELECT asinh( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(2.360325)}},
},
{
Query: "SELECT asinh( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(3.081263)}},
},
{
Query: "SELECT asinh( -10::float8 ) ;",
Expected: []sql.Row{{float64(-2.998223)}},
},
{
Query: "SELECT asinh( 100::float8 ) ;",
Expected: []sql.Row{{float64(5.298342)}},
},
{
Query: "SELECT asinh( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(10.647826)}},
},
{
Query: "SELECT asinh( 100000::float8 ) ;",
Expected: []sql.Row{{float64(12.206073)}},
},
{
Query: "SELECT asinh( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-14.677793)}},
},
{
Query: "SELECT asinh( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(15.435010)}},
},
{
Query: "SELECT asinh( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-22.180710)}},
},
{
Query: "SELECT asinh( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(22.180710)}},
},
},
},
})
}
testing/generation/function_coverage/output/atan2_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Atan2(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "atan2",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT atan2( 0::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 1::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 2::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( -2::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( -10::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 100::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 100000::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( -1::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-2.356194)}},
},
{
Query: "SELECT atan2( 1::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(2.356194)}},
},
{
Query: "SELECT atan2( 2::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(2.034444)}},
},
{
Query: "SELECT atan2( -2::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-2.034444)}},
},
{
Query: "SELECT atan2( 5.25::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(1.759018)}},
},
{
Query: "SELECT atan2( 10.87::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(1.662534)}},
},
{
Query: "SELECT atan2( -10::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.670465)}},
},
{
Query: "SELECT atan2( 100::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(1.580796)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(1.570844)}},
},
{
Query: "SELECT atan2( 100000::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(1.570806)}},
},
{
Query: "SELECT atan2( -1184280::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.570797)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(1.570797)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-0.785398)}},
},
{
Query: "SELECT atan2( 1::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( 2::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.107149)}},
},
{
Query: "SELECT atan2( -2::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-1.107149)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.382575)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.479058)}},
},
{
Query: "SELECT atan2( -10::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-1.471128)}},
},
{
Query: "SELECT atan2( 100::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.560797)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.570749)}},
},
{
Query: "SELECT atan2( 100000::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.570786)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-1.570795)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-0.463648)}},
},
{
Query: "SELECT atan2( 1::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(0.463648)}},
},
{
Query: "SELECT atan2( 2::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( -2::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-0.785398)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(1.206817)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(1.388839)}},
},
{
Query: "SELECT atan2( -10::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-1.373401)}},
},
{
Query: "SELECT atan2( 100::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(1.550799)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(1.570701)}},
},
{
Query: "SELECT atan2( 100000::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(1.570776)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-1.570795)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( -1::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-2.677945)}},
},
{
Query: "SELECT atan2( 1::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(2.677945)}},
},
{
Query: "SELECT atan2( 2::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(2.356194)}},
},
{
Query: "SELECT atan2( -2::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-2.356194)}},
},
{
Query: "SELECT atan2( 5.25::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(1.934775)}},
},
{
Query: "SELECT atan2( 10.87::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(1.752754)}},
},
{
Query: "SELECT atan2( -10::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-1.768192)}},
},
{
Query: "SELECT atan2( 100::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(1.590794)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(1.570891)}},
},
{
Query: "SELECT atan2( 100000::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(1.570816)}},
},
{
Query: "SELECT atan2( -1184280::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-1.570798)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(1.570797)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-0.188222)}},
},
{
Query: "SELECT atan2( 1::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.188222)}},
},
{
Query: "SELECT atan2( 2::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.363979)}},
},
{
Query: "SELECT atan2( -2::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-0.363979)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.120857)}},
},
{
Query: "SELECT atan2( -10::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-1.087349)}},
},
{
Query: "SELECT atan2( 100::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.518344)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.570547)}},
},
{
Query: "SELECT atan2( 100000::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.570744)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-1.570792)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.570794)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-0.091738)}},
},
{
Query: "SELECT atan2( 1::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.091738)}},
},
{
Query: "SELECT atan2( 2::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.181958)}},
},
{
Query: "SELECT atan2( -2::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-0.181958)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.449940)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( -10::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-0.743736)}},
},
{
Query: "SELECT atan2( 100::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.462521)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.570280)}},
},
{
Query: "SELECT atan2( 100000::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.570688)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-1.570787)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.570792)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( -1::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-3.041924)}},
},
{
Query: "SELECT atan2( 1::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(3.041924)}},
},
{
Query: "SELECT atan2( 2::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(2.944197)}},
},
{
Query: "SELECT atan2( -2::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-2.944197)}},
},
{
Query: "SELECT atan2( 5.25::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(2.658146)}},
},
{
Query: "SELECT atan2( 10.87::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(2.314532)}},
},
{
Query: "SELECT atan2( -10::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-2.356194)}},
},
{
Query: "SELECT atan2( 100::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(1.670465)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(1.571271)}},
},
{
Query: "SELECT atan2( 100000::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(1.570896)}},
},
{
Query: "SELECT atan2( -1184280::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-1.570805)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(1.570800)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.010000)}},
},
{
Query: "SELECT atan2( 1::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.010000)}},
},
{
Query: "SELECT atan2( 2::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.019997)}},
},
{
Query: "SELECT atan2( -2::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.019997)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.052452)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.108275)}},
},
{
Query: "SELECT atan2( -10::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.099669)}},
},
{
Query: "SELECT atan2( 100::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(1.566046)}},
},
{
Query: "SELECT atan2( 100000::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(1.569796)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-1.570712)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(1.570757)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan2( 0::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.000048)}},
},
{
Query: "SELECT atan2( 1::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.000048)}},
},
{
Query: "SELECT atan2( 2::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.000095)}},
},
{
Query: "SELECT atan2( -2::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.000095)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.000249)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.000516)}},
},
{
Query: "SELECT atan2( -10::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.000475)}},
},
{
Query: "SELECT atan2( 100::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.004750)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( 100000::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(1.363321)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-1.553023)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(1.562461)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-1.570787)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(1.570787)}},
},
{
Query: "SELECT atan2( 0::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.000010)}},
},
{
Query: "SELECT atan2( 1::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.000010)}},
},
{
Query: "SELECT atan2( 2::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.000020)}},
},
{
Query: "SELECT atan2( -2::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.000020)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.000052)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.000109)}},
},
{
Query: "SELECT atan2( -10::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.000100)}},
},
{
Query: "SELECT atan2( 100::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.001000)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.207476)}},
},
{
Query: "SELECT atan2( 100000::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-1.486557)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(1.531217)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-1.570750)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(1.570750)}},
},
{
Query: "SELECT atan2( 0::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( -1::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-3.141592)}},
},
{
Query: "SELECT atan2( 1::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.141592)}},
},
{
Query: "SELECT atan2( 2::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.141591)}},
},
{
Query: "SELECT atan2( -2::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-3.141591)}},
},
{
Query: "SELECT atan2( 5.25::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.141588)}},
},
{
Query: "SELECT atan2( 10.87::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.141583)}},
},
{
Query: "SELECT atan2( -10::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-3.141584)}},
},
{
Query: "SELECT atan2( 100::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.141508)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.123820)}},
},
{
Query: "SELECT atan2( 100000::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(3.057353)}},
},
{
Query: "SELECT atan2( -1184280::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-2.356194)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(2.009313)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1.571348)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(1.571348)}},
},
{
Query: "SELECT atan2( 0::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.000000)}},
},
{
Query: "SELECT atan2( 1::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( 2::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000001)}},
},
{
Query: "SELECT atan2( -2::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.000001)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000002)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000004)}},
},
{
Query: "SELECT atan2( -10::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.000004)}},
},
{
Query: "SELECT atan2( 100::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000040)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.008336)}},
},
{
Query: "SELECT atan2( 100000::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.039579)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.438517)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-1.569620)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(1.569620)}},
},
{
Query: "SELECT atan2( 0::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( -1::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-3.141593)}},
},
{
Query: "SELECT atan2( 1::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( 2::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( -2::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-3.141593)}},
},
{
Query: "SELECT atan2( 5.25::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( 10.87::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( -10::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-3.141593)}},
},
{
Query: "SELECT atan2( 100::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141583)}},
},
{
Query: "SELECT atan2( 100000::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.141546)}},
},
{
Query: "SELECT atan2( -1184280::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-3.141041)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(3.140417)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-2.356194)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(2.356194)}},
},
{
Query: "SELECT atan2( 0::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -1::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.000000)}},
},
{
Query: "SELECT atan2( 1::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( 2::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -2::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.000000)}},
},
{
Query: "SELECT atan2( 5.25::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( 10.87::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( -10::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.000000)}},
},
{
Query: "SELECT atan2( 100::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2( 21050.48::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000010)}},
},
{
Query: "SELECT atan2( 100000::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000047)}},
},
{
Query: "SELECT atan2( -1184280::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.000551)}},
},
{
Query: "SELECT atan2( 2525280.279::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.001176)}},
},
{
Query: "SELECT atan2( -2147483648::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.785398)}},
},
{
Query: "SELECT atan2( 2147483647.59024::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
},
},
})
}
testing/generation/function_coverage/output/atan2d_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Atan2d(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "atan2d",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT atan2d( 0::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 1::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 2::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( -2::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( -10::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 100::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 0::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-135.000000)}},
},
{
Query: "SELECT atan2d( 1::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(135.000000)}},
},
{
Query: "SELECT atan2d( 2::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(116.565051)}},
},
{
Query: "SELECT atan2d( -2::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-116.565051)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(100.784298)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(95.256206)}},
},
{
Query: "SELECT atan2d( -10::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-95.710593)}},
},
{
Query: "SELECT atan2d( 100::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(90.572939)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(90.002722)}},
},
{
Query: "SELECT atan2d( 100000::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(90.000573)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-90.000048)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(90.000023)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , -1::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-45.000000)}},
},
{
Query: "SELECT atan2d( 1::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( 2::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(63.434949)}},
},
{
Query: "SELECT atan2d( -2::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-63.434949)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(79.215702)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(84.743794)}},
},
{
Query: "SELECT atan2d( -10::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-84.289407)}},
},
{
Query: "SELECT atan2d( 100::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(89.427061)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(89.997278)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(89.999427)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-89.999952)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(89.999977)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 1::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-26.565051)}},
},
{
Query: "SELECT atan2d( 1::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(26.565051)}},
},
{
Query: "SELECT atan2d( 2::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( -2::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-45.000000)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(69.145542)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(79.574599)}},
},
{
Query: "SELECT atan2d( -10::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-78.690068)}},
},
{
Query: "SELECT atan2d( 100::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(88.854237)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(89.994556)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(89.998854)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-89.999903)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(89.999955)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 2::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-153.434949)}},
},
{
Query: "SELECT atan2d( 1::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(153.434949)}},
},
{
Query: "SELECT atan2d( 2::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(135.000000)}},
},
{
Query: "SELECT atan2d( -2::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-135.000000)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(110.854458)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(100.425401)}},
},
{
Query: "SELECT atan2d( -10::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-101.309932)}},
},
{
Query: "SELECT atan2d( 100::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(91.145763)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(90.005444)}},
},
{
Query: "SELECT atan2d( 100000::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(90.001146)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-90.000097)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(90.000045)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , -2::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-10.784298)}},
},
{
Query: "SELECT atan2d( 1::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(10.784298)}},
},
{
Query: "SELECT atan2d( 2::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(20.854458)}},
},
{
Query: "SELECT atan2d( -2::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-20.854458)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(64.220355)}},
},
{
Query: "SELECT atan2d( -10::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-62.300527)}},
},
{
Query: "SELECT atan2d( 100::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(86.994731)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(89.985710)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(89.996992)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-89.999746)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(89.999881)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 5.25::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-5.256206)}},
},
{
Query: "SELECT atan2d( 1::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(5.256206)}},
},
{
Query: "SELECT atan2d( 2::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(10.425401)}},
},
{
Query: "SELECT atan2d( -2::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-10.425401)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(25.779645)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( -10::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-42.612914)}},
},
{
Query: "SELECT atan2d( 100::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(83.796306)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(89.970414)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(89.993772)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-89.999474)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(89.999753)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 10.87::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-174.289407)}},
},
{
Query: "SELECT atan2d( 1::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(174.289407)}},
},
{
Query: "SELECT atan2d( 2::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(168.690068)}},
},
{
Query: "SELECT atan2d( -2::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-168.690068)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(152.300527)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(132.612914)}},
},
{
Query: "SELECT atan2d( -10::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-135.000000)}},
},
{
Query: "SELECT atan2d( 100::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(95.710593)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(90.027218)}},
},
{
Query: "SELECT atan2d( 100000::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(90.005730)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-90.000484)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(90.000227)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , -10::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.572939)}},
},
{
Query: "SELECT atan2d( 1::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(0.572939)}},
},
{
Query: "SELECT atan2d( 2::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(1.145763)}},
},
{
Query: "SELECT atan2d( -2::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-1.145763)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(3.005269)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(6.203694)}},
},
{
Query: "SELECT atan2d( -10::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-5.710593)}},
},
{
Query: "SELECT atan2d( 100::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(89.727819)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(89.942704)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-89.995162)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(89.997731)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(-89.999997)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 100::float8 ) ;",
Expected: []sql.Row{{float64(89.999997)}},
},
{
Query: "SELECT atan2d( 0::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.002722)}},
},
{
Query: "SELECT atan2d( 1::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.002722)}},
},
{
Query: "SELECT atan2d( 2::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.005444)}},
},
{
Query: "SELECT atan2d( -2::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.005444)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.014290)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.029586)}},
},
{
Query: "SELECT atan2d( -10::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.027218)}},
},
{
Query: "SELECT atan2d( 100::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.272181)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(78.112522)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-88.981679)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(89.522399)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-89.999438)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(89.999438)}},
},
{
Query: "SELECT atan2d( 0::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.000573)}},
},
{
Query: "SELECT atan2d( 1::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.000573)}},
},
{
Query: "SELECT atan2d( 2::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.001146)}},
},
{
Query: "SELECT atan2d( -2::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.001146)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.003008)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.006228)}},
},
{
Query: "SELECT atan2d( -10::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.005730)}},
},
{
Query: "SELECT atan2d( 100::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.057296)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(11.887478)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-85.173423)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(87.732297)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(-89.997332)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 100000::float8 ) ;",
Expected: []sql.Row{{float64(89.997332)}},
},
{
Query: "SELECT atan2d( 0::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-179.999952)}},
},
{
Query: "SELECT atan2d( 1::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(179.999952)}},
},
{
Query: "SELECT atan2d( 2::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(179.999903)}},
},
{
Query: "SELECT atan2d( -2::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-179.999903)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(179.999746)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(179.999474)}},
},
{
Query: "SELECT atan2d( -10::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-179.999516)}},
},
{
Query: "SELECT atan2d( 100::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(179.995162)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(178.981679)}},
},
{
Query: "SELECT atan2d( 100000::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(175.173423)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-135.000000)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(115.125155)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-90.031597)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , -1184280::float8 ) ;",
Expected: []sql.Row{{float64(90.031597)}},
},
{
Query: "SELECT atan2d( 0::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.000023)}},
},
{
Query: "SELECT atan2d( 1::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000023)}},
},
{
Query: "SELECT atan2d( 2::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000045)}},
},
{
Query: "SELECT atan2d( -2::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.000045)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000119)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.000247)}},
},
{
Query: "SELECT atan2d( -10::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.000227)}},
},
{
Query: "SELECT atan2d( 100::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.002269)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.477601)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(2.267703)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-25.125155)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-89.932624)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(89.932624)}},
},
{
Query: "SELECT atan2d( 0::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-180.000000)}},
},
{
Query: "SELECT atan2d( 1::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( 2::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( -2::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-180.000000)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(180.000000)}},
},
{
Query: "SELECT atan2d( -10::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-180.000000)}},
},
{
Query: "SELECT atan2d( 100::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(179.999997)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(179.999438)}},
},
{
Query: "SELECT atan2d( 100000::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(179.997332)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-179.968403)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(179.932624)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-135.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(135.000000)}},
},
{
Query: "SELECT atan2d( 0::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -1::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.000000)}},
},
{
Query: "SELECT atan2d( 1::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( 2::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -2::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.000000)}},
},
{
Query: "SELECT atan2d( 5.25::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( 10.87::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan2d( -10::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.000000)}},
},
{
Query: "SELECT atan2d( 100::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000003)}},
},
{
Query: "SELECT atan2d( 21050.48::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.000562)}},
},
{
Query: "SELECT atan2d( 100000::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.002668)}},
},
{
Query: "SELECT atan2d( -1184280::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.031597)}},
},
{
Query: "SELECT atan2d( 2525280.279::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.067376)}},
},
{
Query: "SELECT atan2d( -2147483648::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-45.000000)}},
},
{
Query: "SELECT atan2d( 2147483647.59024::float8 , 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
},
},
})
}
testing/generation/function_coverage/output/atan_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Atan(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "atan",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT atan( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atan( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.785398)}},
},
{
Query: "SELECT atan( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.785398)}},
},
{
Query: "SELECT atan( 2::float8 ) ;",
Expected: []sql.Row{{float64(1.107149)}},
},
{
Query: "SELECT atan( -2::float8 ) ;",
Expected: []sql.Row{{float64(-1.107149)}},
},
{
Query: "SELECT atan( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.382575)}},
},
{
Query: "SELECT atan( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.479058)}},
},
{
Query: "SELECT atan( -10::float8 ) ;",
Expected: []sql.Row{{float64(-1.471128)}},
},
{
Query: "SELECT atan( 100::float8 ) ;",
Expected: []sql.Row{{float64(1.560797)}},
},
{
Query: "SELECT atan( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(1.570749)}},
},
{
Query: "SELECT atan( 100000::float8 ) ;",
Expected: []sql.Row{{float64(1.570786)}},
},
{
Query: "SELECT atan( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1.570795)}},
},
{
Query: "SELECT atan( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
{
Query: "SELECT atan( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-1.570796)}},
},
{
Query: "SELECT atan( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(1.570796)}},
},
},
},
})
}
testing/generation/function_coverage/output/atand_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Atand(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "atand",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT atand( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atand( -1::float8 ) ;",
Expected: []sql.Row{{float64(-45.000000)}},
},
{
Query: "SELECT atand( 1::float8 ) ;",
Expected: []sql.Row{{float64(45.000000)}},
},
{
Query: "SELECT atand( 2::float8 ) ;",
Expected: []sql.Row{{float64(63.434949)}},
},
{
Query: "SELECT atand( -2::float8 ) ;",
Expected: []sql.Row{{float64(-63.434949)}},
},
{
Query: "SELECT atand( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(79.215702)}},
},
{
Query: "SELECT atand( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(84.743794)}},
},
{
Query: "SELECT atand( -10::float8 ) ;",
Expected: []sql.Row{{float64(-84.289407)}},
},
{
Query: "SELECT atand( 100::float8 ) ;",
Expected: []sql.Row{{float64(89.427061)}},
},
{
Query: "SELECT atand( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(89.997278)}},
},
{
Query: "SELECT atand( 100000::float8 ) ;",
Expected: []sql.Row{{float64(89.999427)}},
},
{
Query: "SELECT atand( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-89.999952)}},
},
{
Query: "SELECT atand( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(89.999977)}},
},
{
Query: "SELECT atand( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-90.000000)}},
},
{
Query: "SELECT atand( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(90.000000)}},
},
},
},
})
}
testing/generation/function_coverage/output/atanh_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Atanh(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "atanh",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT atanh( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT atanh( -1::float8 ) ;",
Expected: []sql.Row{{float64(-Inf)}},
},
{
Query: "SELECT atanh( 1::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT atanh( 2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( 5.25::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( 10.87::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( 100::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( 21050.48::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( 100000::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( 2525280.279::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT atanh( 2147483647.59024::float8 ) ;",
ExpectedErr: true,
},
},
},
})
}
testing/generation/function_coverage/output/bit_length_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_BitLength(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "bit_length",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT bit_length( '' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT bit_length( ' ' ) ;",
Expected: []sql.Row{{int32(8)}},
},
{
Query: "SELECT bit_length( '0' ) ;",
Expected: []sql.Row{{int32(8)}},
},
{
Query: "SELECT bit_length( '1' ) ;",
Expected: []sql.Row{{int32(8)}},
},
{
Query: "SELECT bit_length( 'a' ) ;",
Expected: []sql.Row{{int32(8)}},
},
{
Query: "SELECT bit_length( 'abc' ) ;",
Expected: []sql.Row{{int32(24)}},
},
{
Query: "SELECT bit_length( '123' ) ;",
Expected: []sql.Row{{int32(24)}},
},
{
Query: "SELECT bit_length( 'value' ) ;",
Expected: []sql.Row{{int32(40)}},
},
{
Query: "SELECT bit_length( '12345' ) ;",
Expected: []sql.Row{{int32(40)}},
},
{
Query: "SELECT bit_length( 'something' ) ;",
Expected: []sql.Row{{int32(72)}},
},
{
Query: "SELECT bit_length( ' something' ) ;",
Expected: []sql.Row{{int32(80)}},
},
{
Query: "SELECT bit_length( 'something ' ) ;",
Expected: []sql.Row{{int32(80)}},
},
{
Query: "SELECT bit_length( '123456789' ) ;",
Expected: []sql.Row{{int32(72)}},
},
{
Query: "SELECT bit_length( 'a group of words' ) ;",
Expected: []sql.Row{{int32(128)}},
},
{
Query: "SELECT bit_length( '1234567890123456' ) ;",
Expected: []sql.Row{{int32(128)}},
},
},
},
})
}
testing/generation/function_coverage/output/btrim_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Btrim(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "btrim",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT btrim( '' , '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , '' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , '' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , '' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , '' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , '' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , '' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , '' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , '' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , '' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , '' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , '' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , '' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , '' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , '' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '0' , ' ' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , ' ' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , ' ' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , ' ' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , ' ' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , ' ' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , ' ' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , ' ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , ' ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( 'something ' , ' ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( '123456789' , ' ' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , ' ' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , ' ' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , '0' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , '0' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , '0' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '1' , '0' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , '0' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , '0' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , '0' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , '0' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , '0' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , '0' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , '0' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , '0' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , '0' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , '0' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , '0' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , '1' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , '1' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , '1' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , '1' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'a' , '1' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , '1' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , '1' ) ;",
Expected: []sql.Row{{"23"}},
},
{
Query: "SELECT btrim( 'value' , '1' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , '1' ) ;",
Expected: []sql.Row{{"2345"}},
},
{
Query: "SELECT btrim( 'something' , '1' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , '1' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , '1' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , '1' ) ;",
Expected: []sql.Row{{"23456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , '1' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , '1' ) ;",
Expected: []sql.Row{{"234567890123456"}},
},
{
Query: "SELECT btrim( '' , 'a' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , 'a' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , 'a' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , 'a' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , 'a' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'abc' , 'a' ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT btrim( '123' , 'a' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , 'a' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , 'a' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , 'a' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , 'a' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , 'a' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , 'a' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , 'a' ) ;",
Expected: []sql.Row{{" group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , 'a' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , 'abc' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , 'abc' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , 'abc' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'abc' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '123' , 'abc' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , 'abc' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , 'abc' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , 'abc' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , 'abc' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , 'abc' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , 'abc' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , 'abc' ) ;",
Expected: []sql.Row{{" group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , 'abc' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , '123' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , '123' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'a' , '123' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , '123' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'value' , '123' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , '123' ) ;",
Expected: []sql.Row{{"45"}},
},
{
Query: "SELECT btrim( 'something' , '123' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , '123' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , '123' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , '123' ) ;",
Expected: []sql.Row{{"456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , '123' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , '123' ) ;",
Expected: []sql.Row{{"4567890123456"}},
},
{
Query: "SELECT btrim( '' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , 'value' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , 'value' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , 'value' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'abc' , 'value' ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT btrim( '123' , 'value' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '12345' , 'value' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , 'value' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , 'value' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , 'value' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , 'value' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , 'value' ) ;",
Expected: []sql.Row{{" group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , 'value' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , '12345' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , '12345' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'a' , '12345' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , '12345' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'value' , '12345' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'something' , '12345' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , '12345' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , '12345' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , '12345' ) ;",
Expected: []sql.Row{{"6789"}},
},
{
Query: "SELECT btrim( 'a group of words' , '12345' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , '12345' ) ;",
Expected: []sql.Row{{"67890123456"}},
},
{
Query: "SELECT btrim( '' , 'something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , 'something' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , 'something' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , 'something' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , 'something' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , 'something' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , 'something' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , 'something' ) ;",
Expected: []sql.Row{{"valu"}},
},
{
Query: "SELECT btrim( '12345' , 'something' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , 'something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' something' , 'something' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( 'something ' , 'something' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '123456789' , 'something' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , 'something' ) ;",
Expected: []sql.Row{{"a group of word"}},
},
{
Query: "SELECT btrim( '1234567890123456' , 'something' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '0' , ' something' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , ' something' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , ' something' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , ' something' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , ' something' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , ' something' ) ;",
Expected: []sql.Row{{"valu"}},
},
{
Query: "SELECT btrim( '12345' , ' something' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' something' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'something ' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '123456789' , ' something' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , ' something' ) ;",
Expected: []sql.Row{{"a group of word"}},
},
{
Query: "SELECT btrim( '1234567890123456' , ' something' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '0' , 'something ' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , 'something ' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , 'something ' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , 'something ' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , 'something ' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , 'something ' ) ;",
Expected: []sql.Row{{"valu"}},
},
{
Query: "SELECT btrim( '12345' , 'something ' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' something' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'something ' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '123456789' , 'something ' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , 'something ' ) ;",
Expected: []sql.Row{{"a group of word"}},
},
{
Query: "SELECT btrim( '1234567890123456' , 'something ' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , '123456789' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , '123456789' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'a' , '123456789' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , '123456789' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'value' , '123456789' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'something' , '123456789' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , '123456789' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , '123456789' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'a group of words' , '123456789' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , '123456789' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '0' , 'a group of words' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT btrim( '1' , 'a group of words' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT btrim( 'a' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'abc' , 'a group of words' ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT btrim( '123' , 'a group of words' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT btrim( 'value' , 'a group of words' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , 'a group of words' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT btrim( 'something' , 'a group of words' ) ;",
Expected: []sql.Row{{"methin"}},
},
{
Query: "SELECT btrim( ' something' , 'a group of words' ) ;",
Expected: []sql.Row{{"methin"}},
},
{
Query: "SELECT btrim( 'something ' , 'a group of words' ) ;",
Expected: []sql.Row{{"methin"}},
},
{
Query: "SELECT btrim( '123456789' , 'a group of words' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT btrim( 'a group of words' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '1234567890123456' , 'a group of words' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT btrim( '' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( ' ' , '1234567890123456' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT btrim( '0' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( '1' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'a' , '1234567890123456' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT btrim( 'abc' , '1234567890123456' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT btrim( '123' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'value' , '1234567890123456' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT btrim( '12345' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'something' , '1234567890123456' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT btrim( ' something' , '1234567890123456' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT btrim( 'something ' , '1234567890123456' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT btrim( '123456789' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT btrim( 'a group of words' , '1234567890123456' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT btrim( '1234567890123456' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
},
},
})
}
testing/generation/function_coverage/output/cbrt_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Cbrt(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "cbrt",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT cbrt( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT cbrt( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT cbrt( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT cbrt( 2::float8 ) ;",
Expected: []sql.Row{{float64(1.259921)}},
},
{
Query: "SELECT cbrt( -2::float8 ) ;",
Expected: []sql.Row{{float64(-1.259921)}},
},
{
Query: "SELECT cbrt( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.738013)}},
},
{
Query: "SELECT cbrt( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(2.215184)}},
},
{
Query: "SELECT cbrt( -10::float8 ) ;",
Expected: []sql.Row{{float64(-2.154435)}},
},
{
Query: "SELECT cbrt( 100::float8 ) ;",
Expected: []sql.Row{{float64(4.641589)}},
},
{
Query: "SELECT cbrt( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(27.611331)}},
},
{
Query: "SELECT cbrt( 100000::float8 ) ;",
Expected: []sql.Row{{float64(46.415888)}},
},
{
Query: "SELECT cbrt( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-105.799788)}},
},
{
Query: "SELECT cbrt( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(136.176822)}},
},
{
Query: "SELECT cbrt( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-1290.159155)}},
},
{
Query: "SELECT cbrt( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(1290.159155)}},
},
},
},
})
}
testing/generation/function_coverage/output/ceil_test.go
+151
View File
@@ -0,0 +1,151 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Ceil(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "ceil",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT ceil( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT ceil( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT ceil( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT ceil( 2::float8 ) ;",
Expected: []sql.Row{{float64(2.000000)}},
},
{
Query: "SELECT ceil( -2::float8 ) ;",
Expected: []sql.Row{{float64(-2.000000)}},
},
{
Query: "SELECT ceil( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(6.000000)}},
},
{
Query: "SELECT ceil( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(11.000000)}},
},
{
Query: "SELECT ceil( -10::float8 ) ;",
Expected: []sql.Row{{float64(-10.000000)}},
},
{
Query: "SELECT ceil( 100::float8 ) ;",
Expected: []sql.Row{{float64(100.000000)}},
},
{
Query: "SELECT ceil( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(21051.000000)}},
},
{
Query: "SELECT ceil( 100000::float8 ) ;",
Expected: []sql.Row{{float64(100000.000000)}},
},
{
Query: "SELECT ceil( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1184280.000000)}},
},
{
Query: "SELECT ceil( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(2525281.000000)}},
},
{
Query: "SELECT ceil( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-2147483648.000000)}},
},
{
Query: "SELECT ceil( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(2147483648.000000)}},
},
{
Query: "SELECT ceil( 0::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT ceil( -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT ceil( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT ceil( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT ceil( -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT ceil( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT ceil( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT ceil( -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-10")}},
},
{
Query: "SELECT ceil( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("1000")}},
},
{
Query: "SELECT ceil( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("2105076")}},
},
{
Query: "SELECT ceil( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("100000001")}},
},
{
Query: "SELECT ceil( -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("-5184226581")}},
},
{
Query: "SELECT ceil( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("8525267290")}},
},
{
Query: "SELECT ceil( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("-79223372036854775808")}},
},
{
Query: "SELECT ceil( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775807")}},
},
},
},
})
}
testing/generation/function_coverage/output/ceiling_test.go
+151
View File
@@ -0,0 +1,151 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Ceiling(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "ceiling",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT ceiling( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT ceiling( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT ceiling( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT ceiling( 2::float8 ) ;",
Expected: []sql.Row{{float64(2.000000)}},
},
{
Query: "SELECT ceiling( -2::float8 ) ;",
Expected: []sql.Row{{float64(-2.000000)}},
},
{
Query: "SELECT ceiling( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(6.000000)}},
},
{
Query: "SELECT ceiling( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(11.000000)}},
},
{
Query: "SELECT ceiling( -10::float8 ) ;",
Expected: []sql.Row{{float64(-10.000000)}},
},
{
Query: "SELECT ceiling( 100::float8 ) ;",
Expected: []sql.Row{{float64(100.000000)}},
},
{
Query: "SELECT ceiling( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(21051.000000)}},
},
{
Query: "SELECT ceiling( 100000::float8 ) ;",
Expected: []sql.Row{{float64(100000.000000)}},
},
{
Query: "SELECT ceiling( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1184280.000000)}},
},
{
Query: "SELECT ceiling( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(2525281.000000)}},
},
{
Query: "SELECT ceiling( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-2147483648.000000)}},
},
{
Query: "SELECT ceiling( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(2147483648.000000)}},
},
{
Query: "SELECT ceiling( 0::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT ceiling( -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT ceiling( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT ceiling( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT ceiling( -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT ceiling( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT ceiling( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT ceiling( -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-10")}},
},
{
Query: "SELECT ceiling( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("1000")}},
},
{
Query: "SELECT ceiling( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("2105076")}},
},
{
Query: "SELECT ceiling( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("100000001")}},
},
{
Query: "SELECT ceiling( -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("-5184226581")}},
},
{
Query: "SELECT ceiling( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("8525267290")}},
},
{
Query: "SELECT ceiling( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("-79223372036854775808")}},
},
{
Query: "SELECT ceiling( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775807")}},
},
},
},
})
}
testing/generation/function_coverage/output/char_length_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_CharLength(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "char_length",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT char_length( '' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT char_length( ' ' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT char_length( '0' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT char_length( '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT char_length( 'a' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT char_length( 'abc' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT char_length( '123' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT char_length( 'value' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT char_length( '12345' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT char_length( 'something' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT char_length( ' something' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT char_length( 'something ' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT char_length( '123456789' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT char_length( 'a group of words' ) ;",
Expected: []sql.Row{{int32(16)}},
},
{
Query: "SELECT char_length( '1234567890123456' ) ;",
Expected: []sql.Row{{int32(16)}},
},
},
},
})
}
testing/generation/function_coverage/output/character_length_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_CharacterLength(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "character_length",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT character_length( '' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT character_length( ' ' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT character_length( '0' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT character_length( '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT character_length( 'a' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT character_length( 'abc' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT character_length( '123' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT character_length( 'value' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT character_length( '12345' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT character_length( 'something' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT character_length( ' something' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT character_length( 'something ' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT character_length( '123456789' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT character_length( 'a group of words' ) ;",
Expected: []sql.Row{{int32(16)}},
},
{
Query: "SELECT character_length( '1234567890123456' ) ;",
Expected: []sql.Row{{int32(16)}},
},
},
},
})
}
testing/generation/function_coverage/output/chr_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Chr(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "chr",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT chr( 0::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT chr( -1::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT chr( 1::int4 ) ;",
Expected: []sql.Row{{"\x01"}},
},
{
Query: "SELECT chr( 2::int4 ) ;",
Expected: []sql.Row{{"\x02"}},
},
{
Query: "SELECT chr( -2::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT chr( 5::int4 ) ;",
Expected: []sql.Row{{"\x05"}},
},
{
Query: "SELECT chr( 10::int4 ) ;",
Expected: []sql.Row{{"\n"}},
},
{
Query: "SELECT chr( -10::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT chr( 100::int4 ) ;",
Expected: []sql.Row{{"d"}},
},
{
Query: "SELECT chr( 21050::int4 ) ;",
Expected: []sql.Row{{"刺"}},
},
{
Query: "SELECT chr( 100000::int4 ) ;",
Expected: []sql.Row{{"𘚠"}},
},
{
Query: "SELECT chr( -1184280::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT chr( 2525280::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT chr( -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT chr( 2147483647::int4 ) ;",
ExpectedErr: true,
},
},
},
})
}
testing/generation/function_coverage/output/cos_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Cos(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "cos",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT cos( 0::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT cos( -1::float8 ) ;",
Expected: []sql.Row{{float64(0.540302)}},
},
{
Query: "SELECT cos( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.540302)}},
},
{
Query: "SELECT cos( 2::float8 ) ;",
Expected: []sql.Row{{float64(-0.416147)}},
},
{
Query: "SELECT cos( -2::float8 ) ;",
Expected: []sql.Row{{float64(-0.416147)}},
},
{
Query: "SELECT cos( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.512085)}},
},
{
Query: "SELECT cos( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-0.125245)}},
},
{
Query: "SELECT cos( -10::float8 ) ;",
Expected: []sql.Row{{float64(-0.839072)}},
},
{
Query: "SELECT cos( 100::float8 ) ;",
Expected: []sql.Row{{float64(0.862319)}},
},
{
Query: "SELECT cos( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.236172)}},
},
{
Query: "SELECT cos( 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.999361)}},
},
{
Query: "SELECT cos( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(0.994948)}},
},
{
Query: "SELECT cos( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.531019)}},
},
{
Query: "SELECT cos( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(0.237816)}},
},
{
Query: "SELECT cos( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.168831)}},
},
},
},
})
}
testing/generation/function_coverage/output/cosd_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Cosd(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "cosd",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT cosd( 0::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT cosd( -1::float8 ) ;",
Expected: []sql.Row{{float64(0.999848)}},
},
{
Query: "SELECT cosd( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.999848)}},
},
{
Query: "SELECT cosd( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.999391)}},
},
{
Query: "SELECT cosd( -2::float8 ) ;",
Expected: []sql.Row{{float64(0.999391)}},
},
{
Query: "SELECT cosd( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.995805)}},
},
{
Query: "SELECT cosd( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.982058)}},
},
{
Query: "SELECT cosd( -10::float8 ) ;",
Expected: []sql.Row{{float64(0.984808)}},
},
{
Query: "SELECT cosd( 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.173648)}},
},
{
Query: "SELECT cosd( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.986228)}},
},
{
Query: "SELECT cosd( 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.173648)}},
},
{
Query: "SELECT cosd( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-0.500000)}},
},
{
Query: "SELECT cosd( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.495777)}},
},
{
Query: "SELECT cosd( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-0.615661)}},
},
{
Query: "SELECT cosd( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.610010)}},
},
},
},
})
}
testing/generation/function_coverage/output/cosh_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Cosh(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "cosh",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT cosh( 0::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT cosh( -1::float8 ) ;",
Expected: []sql.Row{{float64(1.543081)}},
},
{
Query: "SELECT cosh( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.543081)}},
},
{
Query: "SELECT cosh( 2::float8 ) ;",
Expected: []sql.Row{{float64(3.762196)}},
},
{
Query: "SELECT cosh( -2::float8 ) ;",
Expected: []sql.Row{{float64(3.762196)}},
},
{
Query: "SELECT cosh( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(95.285758)}},
},
{
Query: "SELECT cosh( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(26287.605145)}},
},
{
Query: "SELECT cosh( -10::float8 ) ;",
Expected: []sql.Row{{float64(11013.232920)}},
},
{
Query: "SELECT cosh( 100::float8 ) ;",
Expected: []sql.Row{{float64(13440585709080678047126700217981451777343488.000000)}},
},
{
Query: "SELECT cosh( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT cosh( 100000::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT cosh( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT cosh( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT cosh( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT cosh( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
},
},
})
}
testing/generation/function_coverage/output/cot_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Cot(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "cot",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT cot( 0::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT cot( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.642093)}},
},
{
Query: "SELECT cot( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.642093)}},
},
{
Query: "SELECT cot( 2::float8 ) ;",
Expected: []sql.Row{{float64(-0.457658)}},
},
{
Query: "SELECT cot( -2::float8 ) ;",
Expected: []sql.Row{{float64(0.457658)}},
},
{
Query: "SELECT cot( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-0.596187)}},
},
{
Query: "SELECT cot( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.126239)}},
},
{
Query: "SELECT cot( -10::float8 ) ;",
Expected: []sql.Row{{float64(-1.542351)}},
},
{
Query: "SELECT cot( 100::float8 ) ;",
Expected: []sql.Row{{float64(-1.702957)}},
},
{
Query: "SELECT cot( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.243048)}},
},
{
Query: "SELECT cot( 100000::float8 ) ;",
Expected: []sql.Row{{float64(-27.955088)}},
},
{
Query: "SELECT cot( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-9.910614)}},
},
{
Query: "SELECT cot( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.626674)}},
},
{
Query: "SELECT cot( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(0.244841)}},
},
{
Query: "SELECT cot( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.171289)}},
},
},
},
})
}
testing/generation/function_coverage/output/cotd_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Cotd(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "cotd",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT cotd( 0::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT cotd( -1::float8 ) ;",
Expected: []sql.Row{{float64(-57.289962)}},
},
{
Query: "SELECT cotd( 1::float8 ) ;",
Expected: []sql.Row{{float64(57.289962)}},
},
{
Query: "SELECT cotd( 2::float8 ) ;",
Expected: []sql.Row{{float64(28.636253)}},
},
{
Query: "SELECT cotd( -2::float8 ) ;",
Expected: []sql.Row{{float64(-28.636253)}},
},
{
Query: "SELECT cotd( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(10.882921)}},
},
{
Query: "SELECT cotd( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(5.207610)}},
},
{
Query: "SELECT cotd( -10::float8 ) ;",
Expected: []sql.Row{{float64(-5.671282)}},
},
{
Query: "SELECT cotd( 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.176327)}},
},
{
Query: "SELECT cotd( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-5.962977)}},
},
{
Query: "SELECT cotd( 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.176327)}},
},
{
Query: "SELECT cotd( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-0.577350)}},
},
{
Query: "SELECT cotd( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(0.570876)}},
},
{
Query: "SELECT cotd( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(0.781286)}},
},
{
Query: "SELECT cotd( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.769832)}},
},
},
},
})
}
testing/generation/function_coverage/output/degrees_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Degrees(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "degrees",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT degrees( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT degrees( -1::float8 ) ;",
Expected: []sql.Row{{float64(-57.295780)}},
},
{
Query: "SELECT degrees( 1::float8 ) ;",
Expected: []sql.Row{{float64(57.295780)}},
},
{
Query: "SELECT degrees( 2::float8 ) ;",
Expected: []sql.Row{{float64(114.591559)}},
},
{
Query: "SELECT degrees( -2::float8 ) ;",
Expected: []sql.Row{{float64(-114.591559)}},
},
{
Query: "SELECT degrees( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(300.802842)}},
},
{
Query: "SELECT degrees( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(622.805123)}},
},
{
Query: "SELECT degrees( -10::float8 ) ;",
Expected: []sql.Row{{float64(-572.957795)}},
},
{
Query: "SELECT degrees( 100::float8 ) ;",
Expected: []sql.Row{{float64(5729.577951)}},
},
{
Query: "SELECT degrees( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(1206103.660725)}},
},
{
Query: "SELECT degrees( 100000::float8 ) ;",
Expected: []sql.Row{{float64(5729577.951308)}},
},
{
Query: "SELECT degrees( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-67854245.761753)}},
},
{
Query: "SELECT degrees( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(144687902.074319)}},
},
{
Query: "SELECT degrees( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-123041749603.757690)}},
},
{
Query: "SELECT degrees( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(123041749580.280167)}},
},
},
},
})
}
testing/generation/function_coverage/output/div_test.go
+932
View File
@@ -0,0 +1,932 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Div(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "div",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT div( 0::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( -1::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 1::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 2::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( -2::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 5::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 10::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( -10::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 1000::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 2105076::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( -5184226581::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 8525267290::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( -79223372036854775808::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 79223372036854775807::numeric , 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT div( 0::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 1::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( 2::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT div( -2::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT div( 5::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-5")}},
},
{
Query: "SELECT div( 10::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-10")}},
},
{
Query: "SELECT div( -10::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT div( 1000::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1000")}},
},
{
Query: "SELECT div( 2105076::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-2105076")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-100000000")}},
},
{
Query: "SELECT div( -5184226581::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("5184226581")}},
},
{
Query: "SELECT div( 8525267290::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-8525267290")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775808")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-79223372036854775807")}},
},
{
Query: "SELECT div( 0::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( 1::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 2::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT div( -2::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT div( 5::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT div( 10::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT div( -10::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("-10")}},
},
{
Query: "SELECT div( 1000::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1000")}},
},
{
Query: "SELECT div( 2105076::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("2105076")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("100000000")}},
},
{
Query: "SELECT div( -5184226581::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("-5184226581")}},
},
{
Query: "SELECT div( 8525267290::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("8525267290")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("-79223372036854775808")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 1::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775807")}},
},
{
Query: "SELECT div( 0::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( -2::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( 5::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT div( 10::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT div( -10::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("-5")}},
},
{
Query: "SELECT div( 1000::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("500")}},
},
{
Query: "SELECT div( 2105076::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("1052538")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("50000000")}},
},
{
Query: "SELECT div( -5184226581::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("-2592113290")}},
},
{
Query: "SELECT div( 8525267290::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("4262633645")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("-39611686018427387904")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 2::numeric ) ;",
Expected: []sql.Row{{Numeric("39611686018427387903")}},
},
{
Query: "SELECT div( 0::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( -2::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 5::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT div( 10::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-5")}},
},
{
Query: "SELECT div( -10::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT div( 1000::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-500")}},
},
{
Query: "SELECT div( 2105076::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-1052538")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-50000000")}},
},
{
Query: "SELECT div( -5184226581::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("2592113290")}},
},
{
Query: "SELECT div( 8525267290::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-4262633645")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("39611686018427387904")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-39611686018427387903")}},
},
{
Query: "SELECT div( 0::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 10::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT div( -10::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT div( 1000::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("200")}},
},
{
Query: "SELECT div( 2105076::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("421015")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("20000000")}},
},
{
Query: "SELECT div( -5184226581::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("-1036845316")}},
},
{
Query: "SELECT div( 8525267290::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("1705053458")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("-15844674407370955161")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 5::numeric ) ;",
Expected: []sql.Row{{Numeric("15844674407370955161")}},
},
{
Query: "SELECT div( 0::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( -10::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( 1000::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("100")}},
},
{
Query: "SELECT div( 2105076::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("210507")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("10000000")}},
},
{
Query: "SELECT div( -5184226581::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("-518422658")}},
},
{
Query: "SELECT div( 8525267290::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("852526729")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("-7922337203685477580")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 10::numeric ) ;",
Expected: []sql.Row{{Numeric("7922337203685477580")}},
},
{
Query: "SELECT div( 0::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( -10::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 1000::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-100")}},
},
{
Query: "SELECT div( 2105076::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-210507")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-10000000")}},
},
{
Query: "SELECT div( -5184226581::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("518422658")}},
},
{
Query: "SELECT div( 8525267290::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-852526729")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("7922337203685477580")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-7922337203685477580")}},
},
{
Query: "SELECT div( 0::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -10::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1000::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 2105076::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("2105")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("100000")}},
},
{
Query: "SELECT div( -5184226581::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("-5184226")}},
},
{
Query: "SELECT div( 8525267290::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("8525267")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("-79223372036854775")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775")}},
},
{
Query: "SELECT div( 0::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -10::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1000::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2105076::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("47")}},
},
{
Query: "SELECT div( -5184226581::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("-2462")}},
},
{
Query: "SELECT div( 8525267290::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("4049")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("-37634447419881")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("37634447419881")}},
},
{
Query: "SELECT div( 0::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -10::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1000::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2105076::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( -5184226581::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("-51")}},
},
{
Query: "SELECT div( 8525267290::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("85")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("-792233718510")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("792233718510")}},
},
{
Query: "SELECT div( 0::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -10::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1000::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2105076::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -5184226581::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 8525267290::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("15281618347")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("-15281618347")}},
},
{
Query: "SELECT div( 0::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -10::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1000::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2105076::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -5184226581::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 8525267290::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("-9292772806")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("9292772806")}},
},
{
Query: "SELECT div( 0::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -10::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1000::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2105076::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -5184226581::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 8525267290::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , -79223372036854775808::numeric ) ;",
Skip: true,
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 0::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -1::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -2::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 5::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 10::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -10::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 1000::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 2105076::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 100000000.2345862323456346511423652312416532::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -5184226581::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( 8525267290::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT div( -79223372036854775808::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT div( 79223372036854775807::numeric , 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
},
},
})
}
testing/generation/function_coverage/output/floor_test.go
+151
View File
@@ -0,0 +1,151 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Floor(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "floor",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT floor( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT floor( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT floor( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT floor( 2::float8 ) ;",
Expected: []sql.Row{{float64(2.000000)}},
},
{
Query: "SELECT floor( -2::float8 ) ;",
Expected: []sql.Row{{float64(-2.000000)}},
},
{
Query: "SELECT floor( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(5.000000)}},
},
{
Query: "SELECT floor( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(10.000000)}},
},
{
Query: "SELECT floor( -10::float8 ) ;",
Expected: []sql.Row{{float64(-10.000000)}},
},
{
Query: "SELECT floor( 100::float8 ) ;",
Expected: []sql.Row{{float64(100.000000)}},
},
{
Query: "SELECT floor( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(21050.000000)}},
},
{
Query: "SELECT floor( 100000::float8 ) ;",
Expected: []sql.Row{{float64(100000.000000)}},
},
{
Query: "SELECT floor( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1184280.000000)}},
},
{
Query: "SELECT floor( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(2525280.000000)}},
},
{
Query: "SELECT floor( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-2147483648.000000)}},
},
{
Query: "SELECT floor( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(2147483647.000000)}},
},
{
Query: "SELECT floor( 0::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT floor( -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT floor( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT floor( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT floor( -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT floor( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT floor( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT floor( -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-10")}},
},
{
Query: "SELECT floor( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("1000")}},
},
{
Query: "SELECT floor( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("2105076")}},
},
{
Query: "SELECT floor( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("100000000")}},
},
{
Query: "SELECT floor( -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("-5184226581")}},
},
{
Query: "SELECT floor( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("8525267290")}},
},
{
Query: "SELECT floor( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("-79223372036854775808")}},
},
{
Query: "SELECT floor( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775807")}},
},
},
},
})
}
testing/generation/function_coverage/output/framework_test.go
+322
View File
@@ -0,0 +1,322 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"context"
"errors"
"fmt"
"math"
"os"
"reflect"
"strconv"
"testing"
"time"
"github.com/cockroachdb/apd/v3"
"github.com/dolthub/dolt/go/libraries/utils/svcs"
"github.com/dolthub/go-mysql-server/sql"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgtype"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
dserver "github.com/dolthub/doltgresql/server"
pgtypes "github.com/dolthub/doltgresql/server/types"
"github.com/dolthub/doltgresql/servercfg"
"github.com/dolthub/doltgresql/servercfg/cfgdetails"
"github.com/dolthub/doltgresql/utils"
)
var (
// Inf represent positive infinity as a float64
Inf = math.Inf(0)
// EquivalenceThresholdFloat64 represents the allowable delta for values to be considered equivalent.
// For now, we do not expect all non-integer values to be exactly equivalent due to small computational differences
// between Go and C/C++, so this threshold allows us to check that non-integer values are close enough. Over time,
// we may reduce or remove this value as we become more accurate.
EquivalenceThresholdFloat64 = 0.001
)
// ScriptTest defines a consistent structure for testing queries.
type ScriptTest struct {
// Name of the script.
Name string
// The database to create and use. If not provided, then it defaults to "postgres".
Database string
// The SQL statements to execute as setup, in order. Results are not checked, but statements must not error.
SetUpScript []string
// The set of assertions to make after setup, in order
Assertions []ScriptTestAssertion
// When using RunScripts, setting this on one (or more) tests causes RunScripts to ignore all tests that have this
// set to false (which is the default value). This allows a developer to easily "focus" on a specific test without
// having to comment out other tests, pull it into a different function, etc. In addition, CI ensures that this is
// false before passing, meaning this prevents the commented-out situation where the developer forgets to uncomment
// their code.
Focus bool
// Skip is used to completely skip a test including setup
Skip bool
}
// ScriptTestAssertion are the assertions upon which the script executes its main "testing" logic.
type ScriptTestAssertion struct {
Query string
Expected []sql.Row
ExpectedErr bool
// Skip is used to completely skip a test, not execute its query at all, and record it as a skipped test
// in the test suite results.
Skip bool
}
// RunScript runs the given script.
func RunScript(t *testing.T, script ScriptTest) {
scriptDatabase := script.Database
if len(scriptDatabase) == 0 {
scriptDatabase = "postgres"
}
ctx, conn, controller := CreateServer(t, scriptDatabase)
defer func() {
conn.Close(ctx)
controller.Stop()
err := controller.WaitForStop()
require.NoError(t, err)
}()
t.Run(script.Name, func(t *testing.T) {
runScript(t, script, conn, ctx)
})
}
// runScript runs the script given on the postgres connection provided
func runScript(t *testing.T, script ScriptTest, conn *pgx.Conn, ctx context.Context) {
if script.Skip {
t.Skip("Skip has been set in the script")
}
// Run the setup
for _, query := range script.SetUpScript {
_, err := conn.Exec(ctx, query)
require.NoError(t, err)
}
// Run the assertions
for _, assertion := range script.Assertions {
t.Run(assertion.Query, func(t *testing.T) {
if assertion.Skip {
t.Skip("Skip has been set in the assertion")
}
// If we're skipping the results check, then we call Execute, as it uses a simplified message model.
if assertion.ExpectedErr {
_, err := conn.Exec(ctx, assertion.Query)
if assertion.ExpectedErr {
require.Error(t, err)
} else {
require.NoError(t, err)
}
} else {
rows, err := conn.Query(ctx, assertion.Query)
require.NoError(t, err)
readRows, _, err := ReadRows(rows)
require.NoError(t, err)
if !CompareResults(t, assertion.Expected, readRows) {
// We know it will fail, but this will print a prettier message
assert.Equal(t, assertion.Expected, readRows)
}
}
})
}
}
// RunScripts runs the given collection of scripts.
func RunScripts(t *testing.T, scripts []ScriptTest) {
// First, we'll run through the scripts to check for the Focus variable. If it's true, then append it to the new slice.
focusScripts := make([]ScriptTest, 0, len(scripts))
for _, script := range scripts {
if script.Focus {
// If this is running in GitHub Actions, then we'll panic, because someone forgot to disable it before committing
if _, ok := os.LookupEnv("GITHUB_ACTION"); ok {
panic(fmt.Sprintf("The script `%s` has Focus set to `true`. GitHub Actions requires that "+
"all tests are run, which Focus circumvents, leading to this error. Please disable Focus on "+
"all tests.", script.Name))
}
focusScripts = append(focusScripts, script)
}
}
// If we have scripts with Focus set, then we replace the normal script slice with the new slice.
if len(focusScripts) > 0 {
scripts = focusScripts
}
for _, script := range scripts {
RunScript(t, script)
}
}
func ptr[T any](val T) *T {
return &val
}
// CreateServer creates a server with the given database, returning a connection to the server. The server will close
// when the connection is closed (or loses its connection to the server). The accompanying WaitGroup may be used to wait
// until the server has closed.
func CreateServer(t *testing.T, database string) (context.Context, *pgx.Conn, *svcs.Controller) {
require.NotEmpty(t, database)
port, err := sql.GetEmptyPort()
require.NoError(t, err)
controller, err := dserver.RunInMemory(&servercfg.DoltgresConfig{
DoltgresConfig: cfgdetails.DoltgresConfig{
ListenerConfig: &cfgdetails.DoltgresListenerConfig{
PortNumber: &port,
HostStr: ptr("127.0.0.1"),
},
},
}, dserver.NewListener)
require.NoError(t, err)
ctx := context.Background()
err = func() error {
// The connection attempt may be made before the server has grabbed the port, so we'll retry the first
// connection a few times.
var conn *pgx.Conn
var err error
for i := 0; i < 3; i++ {
conn, err = pgx.Connect(ctx, fmt.Sprintf("postgres://postgres:password@127.0.0.1:%d/", port))
if err == nil {
break
} else {
time.Sleep(time.Second)
}
}
if err != nil {
return err
}
defer conn.Close(ctx)
if database != "postgres" {
_, err = conn.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s;", database))
return err
}
return nil
}()
require.NoError(t, err)
conn, err := pgx.Connect(ctx, fmt.Sprintf("postgres://postgres:password@127.0.0.1:%d/%s", port, database))
require.NoError(t, err)
return ctx, conn, controller
}
// ReadRows reads all of the given rows into a slice, then closes the rows.
func ReadRows(rows pgx.Rows) (readRows []sql.Row, oids []uint32, err error) {
for _, desc := range rows.FieldDescriptions() {
oids = append(oids, desc.DataTypeOID)
}
defer func() {
err = errors.Join(err, rows.Err())
}()
for rows.Next() {
row, err := rows.Values()
if err != nil {
return nil, nil, err
}
readRows = append(readRows, row)
}
return readRows, oids, nil
}
// Numeric creates a numeric value from a string.
func Numeric(str string) pgtype.Numeric {
numeric := pgtype.Numeric{}
if err := numeric.Scan(str); err != nil {
panic(err)
}
return numeric
}
// NumericToDecimal converts a pgtype.Numeric value to a apd.Decimal value.
func NumericToDecimal(val pgtype.Numeric) *apd.Decimal {
if val.NaN {
return pgtypes.NumericNaN
} else if val.InfinityModifier == pgtype.Infinity {
return pgtypes.NumericInf
} else if val.InfinityModifier == pgtype.NegativeInfinity {
return pgtypes.NumericNegInf
}
return apd.New(val.Int.Int64(), val.Exp)
}
// CompareResults compares two sets of results, taking the equivalence thresholds into account when making the
// comparisons.
func CompareResults(t *testing.T, a []sql.Row, b []sql.Row) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if !CompareRows(t, a[i], b[i]) {
return false
}
}
return true
}
// CompareRows compares two rows, taking the equivalence thresholds into account when making the comparisons.
func CompareRows(t *testing.T, a sql.Row, b sql.Row) bool {
if len(a) != len(b) {
return false
}
for i := range a {
aVal := a[i]
bVal := b[i]
if aVal != bVal {
if reflect.TypeOf(aVal) != reflect.TypeOf(bVal) {
return false
}
switch aVal.(type) {
case float32:
if utils.Abs(aVal.(float32)-bVal.(float32)) > float32(EquivalenceThresholdFloat64) {
return false
}
case float64:
if utils.Abs(aVal.(float64)-bVal.(float64)) > EquivalenceThresholdFloat64 {
return false
}
case pgtype.Numeric:
aDec := NumericToDecimal(aVal.(pgtype.Numeric))
bDec := NumericToDecimal(bVal.(pgtype.Numeric))
p := aDec.NumDigits()
if p2 := bDec.NumDigits(); p < p2 {
p = p2
}
res := new(apd.Decimal)
_, err := sql.DecimalCtx.WithPrecision(uint32(p)).Sub(res, aDec, bDec)
if err != nil {
return false
}
// EquivalenceThresholdNumeric represents the allowable delta for values to be considered equivalent.
// This is computed using the float64 variant so that they're equivalent.
EquivalenceThresholdNumeric, _, _ := apd.NewFromString(strconv.FormatFloat(EquivalenceThresholdFloat64, 'f', -1, 64))
if res.Abs(res).Cmp(EquivalenceThresholdNumeric) == 1 {
return false
}
default:
return false
}
t.Log("values are not equal but fall within equivalence threshold")
}
}
return true
}
testing/generation/function_coverage/output/gcd_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Gcd(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "gcd",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT gcd( 0::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT gcd( -1::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 10::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -10::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 1000::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 0::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
{
Query: "SELECT gcd( 0::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -1::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -2::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 5::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 10::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -10::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1000::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2105076::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 100000000::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , -1::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -1::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -2::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 5::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 10::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -10::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1000::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 1::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -1::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 10::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -10::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 1000::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 2::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -1::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 10::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -10::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 1000::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 2105076::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 100000000::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , -2::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( -1::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -2::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 5::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 10::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( -10::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 1000::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 5::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -1::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 10::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -10::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 1000::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 10::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -1::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 10::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -10::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 1000::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 2105076::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 100000000::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , -10::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT gcd( -1::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 10::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -10::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 1000::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(4)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 1000::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT gcd( -1::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 10::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -10::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 1000::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(4)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(4)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(3)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 2105076::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT gcd( -1::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 10::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -10::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 1000::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(4)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 100000000::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT gcd( -1::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -2::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 5::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 10::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -10::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1000::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2105076::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(3)}},
},
{
Query: "SELECT gcd( 100000000::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , -5184226581::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT gcd( -1::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( -2::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 5::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT gcd( 10::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -10::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 1000::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 8525267290::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 0::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( -1::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 1::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 2::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( -2::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 5::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 10::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( -10::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 1000::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 2105076::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 100000000::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( -5184226581::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 8525267290::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 0::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
{
Query: "SELECT gcd( -1::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -2::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 5::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 10::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -10::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 1000::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 2105076::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 100000000::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -5184226581::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( 8525267290::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT gcd( -9223372036854775808::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT gcd( 9223372036854775807::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
},
},
})
}
testing/generation/function_coverage/output/initcap_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Initcap(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "initcap",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT initcap( '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT initcap( ' ' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT initcap( '0' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT initcap( '1' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT initcap( 'a' ) ;",
Expected: []sql.Row{{"A"}},
},
{
Query: "SELECT initcap( 'abc' ) ;",
Expected: []sql.Row{{"Abc"}},
},
{
Query: "SELECT initcap( '123' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT initcap( 'value' ) ;",
Expected: []sql.Row{{"Value"}},
},
{
Query: "SELECT initcap( '12345' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT initcap( 'something' ) ;",
Expected: []sql.Row{{"Something"}},
},
{
Query: "SELECT initcap( ' something' ) ;",
Expected: []sql.Row{{" Something"}},
},
{
Query: "SELECT initcap( 'something ' ) ;",
Expected: []sql.Row{{"Something "}},
},
{
Query: "SELECT initcap( '123456789' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT initcap( 'a group of words' ) ;",
Expected: []sql.Row{{"A Group Of Words"}},
},
{
Query: "SELECT initcap( '1234567890123456' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
},
},
})
}
testing/generation/function_coverage/output/lcm_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Lcm(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "lcm",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT lcm( 0::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 1::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 2::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -2::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 5::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 10::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -10::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 1000::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 0::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 0::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( 0::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT lcm( 1::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT lcm( 2::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( -2::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 5::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT lcm( 10::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -10::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1000::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 100000000::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , -1::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , -1::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
{
Query: "SELECT lcm( 0::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT lcm( 1::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1)}},
},
{
Query: "SELECT lcm( 2::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( -2::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 5::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT lcm( 10::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -10::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1000::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 1::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 1::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
{
Query: "SELECT lcm( 0::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 1::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 2::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( -2::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 5::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 10::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -10::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1000::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(10368453162)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 2::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 2::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 2::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 1::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 2::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( -2::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2)}},
},
{
Query: "SELECT lcm( 5::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 10::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -10::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1000::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 100000000::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(10368453162)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , -2::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , -2::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , -2::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT lcm( 1::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT lcm( 2::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -2::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 5::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(5)}},
},
{
Query: "SELECT lcm( 10::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -10::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1000::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(10525380)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(25921132905)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 5::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 5::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 5::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 2::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -2::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 5::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 10::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -10::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1000::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(10525380)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(51842265810)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 10::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 10::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 10::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 2::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -2::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 5::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 10::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( -10::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10)}},
},
{
Query: "SELECT lcm( 1000::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(10525380)}},
},
{
Query: "SELECT lcm( 100000000::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(51842265810)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , -10::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , -10::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , -10::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 1::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( -2::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 5::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 10::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( -10::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 1000::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(1000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(526269000)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(5184226581000)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 1000::int8 ) ;",
Expected: []sql.Row{{int64(852526729000)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 1000::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 1000::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 1::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 2::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( -2::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 5::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(10525380)}},
},
{
Query: "SELECT lcm( 10::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(10525380)}},
},
{
Query: "SELECT lcm( -10::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(10525380)}},
},
{
Query: "SELECT lcm( 1000::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(526269000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(2105076)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(52626900000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(3637730318075052)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 2105076::int8 ) ;",
Expected: []sql.Row{{int64(8973167782882020)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 2105076::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 2105076::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( 1::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( 2::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -2::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( 5::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( 10::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -10::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( 1000::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(52626900000000)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(518422658100000000)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , 100000000::int8 ) ;",
Expected: []sql.Row{{int64(85252672900000000)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 100000000::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 100000000::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT lcm( 1::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT lcm( 2::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(10368453162)}},
},
{
Query: "SELECT lcm( -2::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(10368453162)}},
},
{
Query: "SELECT lcm( 5::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(25921132905)}},
},
{
Query: "SELECT lcm( 10::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(51842265810)}},
},
{
Query: "SELECT lcm( -10::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(51842265810)}},
},
{
Query: "SELECT lcm( 1000::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(5184226581000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(3637730318075052)}},
},
{
Query: "SELECT lcm( 100000000::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(518422658100000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , -5184226581::int8 ) ;",
Expected: []sql.Row{{int64(5184226581)}},
},
{
Query: "SELECT lcm( 8525267290::int8 , -5184226581::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , -5184226581::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , -5184226581::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( 1::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( 2::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -2::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( 5::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( 10::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -10::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( 1000::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(852526729000)}},
},
{
Query: "SELECT lcm( 2105076::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8973167782882020)}},
},
{
Query: "SELECT lcm( 100000000::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(85252672900000000)}},
},
{
Query: "SELECT lcm( -5184226581::int8 , 8525267290::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 8525267290::int8 , 8525267290::int8 ) ;",
Expected: []sql.Row{{int64(8525267290)}},
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 8525267290::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 8525267290::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -1::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 1::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 2::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -2::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 5::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 10::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -10::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 1000::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 2105076::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 100000000::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -5184226581::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 8525267290::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 0::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(0)}},
},
{
Query: "SELECT lcm( -1::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
{
Query: "SELECT lcm( 1::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
{
Query: "SELECT lcm( 2::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -2::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 5::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 10::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -10::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 1000::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 2105076::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 100000000::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -5184226581::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 8525267290::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( -9223372036854775808::int8 , 9223372036854775807::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT lcm( 9223372036854775807::int8 , 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{int64(9223372036854775807)}},
},
},
},
})
}
testing/generation/function_coverage/output/left_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Left(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "left",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT left( '' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '0' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '1' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'abc' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '123' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'value' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '12345' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'something' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' something' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'something ' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '123456789' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a group of words' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '1234567890123456' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '0' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '1' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'abc' , -1::int4 ) ;",
Expected: []sql.Row{{"ab"}},
},
{
Query: "SELECT left( '123' , -1::int4 ) ;",
Expected: []sql.Row{{"12"}},
},
{
Query: "SELECT left( 'value' , -1::int4 ) ;",
Expected: []sql.Row{{"valu"}},
},
{
Query: "SELECT left( '12345' , -1::int4 ) ;",
Expected: []sql.Row{{"1234"}},
},
{
Query: "SELECT left( 'something' , -1::int4 ) ;",
Expected: []sql.Row{{"somethin"}},
},
{
Query: "SELECT left( ' something' , -1::int4 ) ;",
Expected: []sql.Row{{" somethin"}},
},
{
Query: "SELECT left( 'something ' , -1::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT left( '123456789' , -1::int4 ) ;",
Expected: []sql.Row{{"12345678"}},
},
{
Query: "SELECT left( 'a group of words' , -1::int4 ) ;",
Expected: []sql.Row{{"a group of word"}},
},
{
Query: "SELECT left( '1234567890123456' , -1::int4 ) ;",
Expected: []sql.Row{{"123456789012345"}},
},
{
Query: "SELECT left( '' , 1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 1::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 1::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 1::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 1::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 1::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( '123' , 1::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'value' , 1::int4 ) ;",
Expected: []sql.Row{{"v"}},
},
{
Query: "SELECT left( '12345' , 1::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'something' , 1::int4 ) ;",
Expected: []sql.Row{{"s"}},
},
{
Query: "SELECT left( ' something' , 1::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( 'something ' , 1::int4 ) ;",
Expected: []sql.Row{{"s"}},
},
{
Query: "SELECT left( '123456789' , 1::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a group of words' , 1::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( '1234567890123456' , 1::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( '' , 2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 2::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 2::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 2::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 2::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 2::int4 ) ;",
Expected: []sql.Row{{"ab"}},
},
{
Query: "SELECT left( '123' , 2::int4 ) ;",
Expected: []sql.Row{{"12"}},
},
{
Query: "SELECT left( 'value' , 2::int4 ) ;",
Expected: []sql.Row{{"va"}},
},
{
Query: "SELECT left( '12345' , 2::int4 ) ;",
Expected: []sql.Row{{"12"}},
},
{
Query: "SELECT left( 'something' , 2::int4 ) ;",
Expected: []sql.Row{{"so"}},
},
{
Query: "SELECT left( ' something' , 2::int4 ) ;",
Expected: []sql.Row{{" s"}},
},
{
Query: "SELECT left( 'something ' , 2::int4 ) ;",
Expected: []sql.Row{{"so"}},
},
{
Query: "SELECT left( '123456789' , 2::int4 ) ;",
Expected: []sql.Row{{"12"}},
},
{
Query: "SELECT left( 'a group of words' , 2::int4 ) ;",
Expected: []sql.Row{{"a "}},
},
{
Query: "SELECT left( '1234567890123456' , 2::int4 ) ;",
Expected: []sql.Row{{"12"}},
},
{
Query: "SELECT left( '' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '0' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '1' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'abc' , -2::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( '123' , -2::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'value' , -2::int4 ) ;",
Expected: []sql.Row{{"val"}},
},
{
Query: "SELECT left( '12345' , -2::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'something' , -2::int4 ) ;",
Expected: []sql.Row{{"somethi"}},
},
{
Query: "SELECT left( ' something' , -2::int4 ) ;",
Expected: []sql.Row{{" somethi"}},
},
{
Query: "SELECT left( 'something ' , -2::int4 ) ;",
Expected: []sql.Row{{"somethin"}},
},
{
Query: "SELECT left( '123456789' , -2::int4 ) ;",
Expected: []sql.Row{{"1234567"}},
},
{
Query: "SELECT left( 'a group of words' , -2::int4 ) ;",
Expected: []sql.Row{{"a group of wor"}},
},
{
Query: "SELECT left( '1234567890123456' , -2::int4 ) ;",
Expected: []sql.Row{{"12345678901234"}},
},
{
Query: "SELECT left( '' , 5::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 5::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 5::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 5::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 5::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 5::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT left( '123' , 5::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'value' , 5::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT left( '12345' , 5::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'something' , 5::int4 ) ;",
Expected: []sql.Row{{"somet"}},
},
{
Query: "SELECT left( ' something' , 5::int4 ) ;",
Expected: []sql.Row{{" some"}},
},
{
Query: "SELECT left( 'something ' , 5::int4 ) ;",
Expected: []sql.Row{{"somet"}},
},
{
Query: "SELECT left( '123456789' , 5::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'a group of words' , 5::int4 ) ;",
Expected: []sql.Row{{"a gro"}},
},
{
Query: "SELECT left( '1234567890123456' , 5::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( '' , 10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 10::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 10::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 10::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 10::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 10::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT left( '123' , 10::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'value' , 10::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT left( '12345' , 10::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'something' , 10::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT left( ' something' , 10::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT left( 'something ' , 10::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT left( '123456789' , 10::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT left( 'a group of words' , 10::int4 ) ;",
Expected: []sql.Row{{"a group of"}},
},
{
Query: "SELECT left( '1234567890123456' , 10::int4 ) ;",
Expected: []sql.Row{{"1234567890"}},
},
{
Query: "SELECT left( '' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '0' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '1' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'abc' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '123' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'value' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '12345' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'something' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' something' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'something ' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '123456789' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a group of words' , -10::int4 ) ;",
Expected: []sql.Row{{"a grou"}},
},
{
Query: "SELECT left( '1234567890123456' , -10::int4 ) ;",
Expected: []sql.Row{{"123456"}},
},
{
Query: "SELECT left( '' , 100::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 100::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 100::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 100::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 100::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 100::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT left( '123' , 100::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'value' , 100::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT left( '12345' , 100::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'something' , 100::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT left( ' something' , 100::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT left( 'something ' , 100::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT left( '123456789' , 100::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT left( 'a group of words' , 100::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT left( '1234567890123456' , 100::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT left( '' , 21050::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 21050::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 21050::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 21050::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 21050::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 21050::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT left( '123' , 21050::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'value' , 21050::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT left( '12345' , 21050::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'something' , 21050::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT left( ' something' , 21050::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT left( 'something ' , 21050::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT left( '123456789' , 21050::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT left( 'a group of words' , 21050::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT left( '1234567890123456' , 21050::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT left( '' , 100000::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 100000::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 100000::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 100000::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 100000::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 100000::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT left( '123' , 100000::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'value' , 100000::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT left( '12345' , 100000::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'something' , 100000::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT left( ' something' , 100000::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT left( 'something ' , 100000::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT left( '123456789' , 100000::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT left( 'a group of words' , 100000::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT left( '1234567890123456' , 100000::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT left( '' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '0' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '1' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'abc' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '123' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'value' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '12345' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'something' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' something' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'something ' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '123456789' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( 'a group of words' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '1234567890123456' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( '' , 2525280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 2525280::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 2525280::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 2525280::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 2525280::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 2525280::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT left( '123' , 2525280::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'value' , 2525280::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT left( '12345' , 2525280::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'something' , 2525280::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT left( ' something' , 2525280::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT left( 'something ' , 2525280::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT left( '123456789' , 2525280::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT left( 'a group of words' , 2525280::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT left( '1234567890123456' , 2525280::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT left( '' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( ' ' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( '0' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( '1' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( 'a' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( 'abc' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( '123' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( 'value' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( '12345' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( 'something' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( ' something' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( 'something ' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( '123456789' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( 'a group of words' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( '1234567890123456' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT left( '' , 2147483647::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT left( ' ' , 2147483647::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT left( '0' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT left( '1' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT left( 'a' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT left( 'abc' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT left( '123' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT left( 'value' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT left( '12345' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT left( 'something' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT left( ' something' , 2147483647::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT left( 'something ' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT left( '123456789' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT left( 'a group of words' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT left( '1234567890123456' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
},
},
})
}
testing/generation/function_coverage/output/length_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Length(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "length",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT length( '' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT length( ' ' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT length( '0' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT length( '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT length( 'a' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT length( 'abc' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT length( '123' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT length( 'value' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT length( '12345' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT length( 'something' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT length( ' something' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT length( 'something ' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT length( '123456789' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT length( 'a group of words' ) ;",
Expected: []sql.Row{{int32(16)}},
},
{
Query: "SELECT length( '1234567890123456' ) ;",
Expected: []sql.Row{{int32(16)}},
},
},
},
})
}
testing/generation/function_coverage/output/ln_test.go
+151
View File
@@ -0,0 +1,151 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Ln(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "ln",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT ln( 0::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( -1::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT ln( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.693147)}},
},
{
Query: "SELECT ln( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.658228)}},
},
{
Query: "SELECT ln( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(2.386007)}},
},
{
Query: "SELECT ln( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 100::float8 ) ;",
Expected: []sql.Row{{float64(4.605170)}},
},
{
Query: "SELECT ln( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(9.954679)}},
},
{
Query: "SELECT ln( 100000::float8 ) ;",
Expected: []sql.Row{{float64(11.512925)}},
},
{
Query: "SELECT ln( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(14.741863)}},
},
{
Query: "SELECT ln( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(21.487563)}},
},
{
Query: "SELECT ln( 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( -1::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT ln( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("0.6931471805599453")}},
},
{
Query: "SELECT ln( -2::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("1.6094379124341004")}},
},
{
Query: "SELECT ln( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("2.3025850929940457")}},
},
{
Query: "SELECT ln( -10::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("6.9077552789821371")}},
},
{
Query: "SELECT ln( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("14.559862128959931")}},
},
{
Query: "SELECT ln( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("18.4206807462982277928487431328957099")}},
},
{
Query: "SELECT ln( -5184226581::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("22.866300213290165")}},
},
{
Query: "SELECT ln( -79223372036854775808::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT ln( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("45.818803030654766")}},
},
},
},
})
}
testing/generation/function_coverage/output/log10_test.go
+151
View File
@@ -0,0 +1,151 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Log10(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "log10",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT log10( 0::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( -1::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT log10( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.301030)}},
},
{
Query: "SELECT log10( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.720159)}},
},
{
Query: "SELECT log10( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.036230)}},
},
{
Query: "SELECT log10( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 100::float8 ) ;",
Expected: []sql.Row{{float64(2.000000)}},
},
{
Query: "SELECT log10( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(4.323262)}},
},
{
Query: "SELECT log10( 100000::float8 ) ;",
Expected: []sql.Row{{float64(5.000000)}},
},
{
Query: "SELECT log10( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(6.402310)}},
},
{
Query: "SELECT log10( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(9.331930)}},
},
{
Query: "SELECT log10( 0::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( -1::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT log10( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("0.3010299956639812")}},
},
{
Query: "SELECT log10( -2::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("0.6989700043360188")}},
},
{
Query: "SELECT log10( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("1.0000000000000000")}},
},
{
Query: "SELECT log10( -10::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("3.0000000000000000")}},
},
{
Query: "SELECT log10( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("6.323267779879430")}},
},
{
Query: "SELECT log10( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("8.0000000010187950611868560912011483")}},
},
{
Query: "SELECT log10( -5184226581::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("9.930708004175069")}},
},
{
Query: "SELECT log10( -79223372036854775808::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT log10( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("19.898853323625356")}},
},
},
},
})
}
testing/generation/function_coverage/output/log_test.go
+1051
View File
File diff suppressed because it is too large Load Diff
testing/generation/function_coverage/output/lower_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Lower(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "lower",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT lower( '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT lower( ' ' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT lower( '0' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT lower( '1' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT lower( 'a' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT lower( 'abc' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT lower( '123' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT lower( 'value' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT lower( '12345' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT lower( 'something' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT lower( ' something' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT lower( 'something ' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT lower( '123456789' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT lower( 'a group of words' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT lower( '1234567890123456' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
},
},
})
}
testing/generation/function_coverage/output/ltrim_test.go
+991
View File
@@ -0,0 +1,991 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Ltrim(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "ltrim",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT ltrim( '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '0' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( 'something ' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , '' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , '' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , '' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , '' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , '' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , '' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , '' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , '' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , '' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , '' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , '' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , '' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , '' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , '' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '0' , ' ' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , ' ' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , ' ' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , ' ' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , ' ' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , ' ' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , ' ' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , ' ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , ' ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( 'something ' , ' ' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , ' ' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , ' ' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , ' ' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , '0' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , '0' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , '0' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '1' , '0' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , '0' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , '0' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , '0' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , '0' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , '0' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , '0' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , '0' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , '0' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , '0' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , '0' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , '0' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , '1' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , '1' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , '1' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , '1' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'a' , '1' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , '1' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , '1' ) ;",
Expected: []sql.Row{{"23"}},
},
{
Query: "SELECT ltrim( 'value' , '1' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , '1' ) ;",
Expected: []sql.Row{{"2345"}},
},
{
Query: "SELECT ltrim( 'something' , '1' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , '1' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , '1' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , '1' ) ;",
Expected: []sql.Row{{"23456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , '1' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , '1' ) ;",
Expected: []sql.Row{{"234567890123456"}},
},
{
Query: "SELECT ltrim( '' , 'a' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , 'a' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , 'a' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , 'a' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , 'a' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'abc' , 'a' ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT ltrim( '123' , 'a' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , 'a' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , 'a' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , 'a' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , 'a' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , 'a' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , 'a' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , 'a' ) ;",
Expected: []sql.Row{{" group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , 'a' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , 'abc' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , 'abc' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , 'abc' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'abc' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '123' , 'abc' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , 'abc' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , 'abc' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , 'abc' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , 'abc' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , 'abc' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , 'abc' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , 'abc' ) ;",
Expected: []sql.Row{{" group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , 'abc' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , '123' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , '123' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'a' , '123' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , '123' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'value' , '123' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , '123' ) ;",
Expected: []sql.Row{{"45"}},
},
{
Query: "SELECT ltrim( 'something' , '123' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , '123' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , '123' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , '123' ) ;",
Expected: []sql.Row{{"456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , '123' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , '123' ) ;",
Expected: []sql.Row{{"4567890123456"}},
},
{
Query: "SELECT ltrim( '' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , 'value' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , 'value' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , 'value' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'abc' , 'value' ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT ltrim( '123' , 'value' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '12345' , 'value' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , 'value' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , 'value' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , 'value' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , 'value' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , 'value' ) ;",
Expected: []sql.Row{{" group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , 'value' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , '12345' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , '12345' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'a' , '12345' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , '12345' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'value' , '12345' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'something' , '12345' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , '12345' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , '12345' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , '12345' ) ;",
Expected: []sql.Row{{"6789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , '12345' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , '12345' ) ;",
Expected: []sql.Row{{"67890123456"}},
},
{
Query: "SELECT ltrim( '' , 'something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , 'something' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , 'something' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , 'something' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , 'something' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , 'something' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , 'something' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , 'something' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , 'something' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , 'something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' something' , 'something' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , 'something' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '123456789' , 'something' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , 'something' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , 'something' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '0' , ' something' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , ' something' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , ' something' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , ' something' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , ' something' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , ' something' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , ' something' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' something' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'something ' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '123456789' , ' something' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , ' something' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , ' something' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '0' , 'something ' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , 'something ' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , 'something ' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , 'something ' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , 'something ' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , 'something ' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , 'something ' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' something' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'something ' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '123456789' , 'something ' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , 'something ' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , 'something ' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , '123456789' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , '123456789' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'a' , '123456789' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , '123456789' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'value' , '123456789' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'something' , '123456789' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , '123456789' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , '123456789' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'a group of words' , '123456789' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , '123456789' ) ;",
Expected: []sql.Row{{"0123456"}},
},
{
Query: "SELECT ltrim( '' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '0' , 'a group of words' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT ltrim( '1' , 'a group of words' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT ltrim( 'a' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'abc' , 'a group of words' ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT ltrim( '123' , 'a group of words' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT ltrim( 'value' , 'a group of words' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , 'a group of words' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT ltrim( 'something' , 'a group of words' ) ;",
Expected: []sql.Row{{"mething"}},
},
{
Query: "SELECT ltrim( ' something' , 'a group of words' ) ;",
Expected: []sql.Row{{"mething"}},
},
{
Query: "SELECT ltrim( 'something ' , 'a group of words' ) ;",
Expected: []sql.Row{{"mething "}},
},
{
Query: "SELECT ltrim( '123456789' , 'a group of words' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT ltrim( 'a group of words' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '1234567890123456' , 'a group of words' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT ltrim( '' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( ' ' , '1234567890123456' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT ltrim( '0' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( '1' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'a' , '1234567890123456' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT ltrim( 'abc' , '1234567890123456' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT ltrim( '123' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'value' , '1234567890123456' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT ltrim( '12345' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'something' , '1234567890123456' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT ltrim( ' something' , '1234567890123456' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT ltrim( 'something ' , '1234567890123456' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT ltrim( '123456789' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT ltrim( 'a group of words' , '1234567890123456' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT ltrim( '1234567890123456' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
},
},
})
}
testing/generation/function_coverage/output/md5_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Md5(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "md5",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT md5( '' ) ;",
Expected: []sql.Row{{"d41d8cd98f00b204e9800998ecf8427e"}},
},
{
Query: "SELECT md5( ' ' ) ;",
Expected: []sql.Row{{"7215ee9c7d9dc229d2921a40e899ec5f"}},
},
{
Query: "SELECT md5( '0' ) ;",
Expected: []sql.Row{{"cfcd208495d565ef66e7dff9f98764da"}},
},
{
Query: "SELECT md5( '1' ) ;",
Expected: []sql.Row{{"c4ca4238a0b923820dcc509a6f75849b"}},
},
{
Query: "SELECT md5( 'a' ) ;",
Expected: []sql.Row{{"0cc175b9c0f1b6a831c399e269772661"}},
},
{
Query: "SELECT md5( 'abc' ) ;",
Expected: []sql.Row{{"900150983cd24fb0d6963f7d28e17f72"}},
},
{
Query: "SELECT md5( '123' ) ;",
Expected: []sql.Row{{"202cb962ac59075b964b07152d234b70"}},
},
{
Query: "SELECT md5( 'value' ) ;",
Expected: []sql.Row{{"2063c1608d6e0baf80249c42e2be5804"}},
},
{
Query: "SELECT md5( '12345' ) ;",
Expected: []sql.Row{{"827ccb0eea8a706c4c34a16891f84e7b"}},
},
{
Query: "SELECT md5( 'something' ) ;",
Expected: []sql.Row{{"437b930db84b8079c2dd804a71936b5f"}},
},
{
Query: "SELECT md5( ' something' ) ;",
Expected: []sql.Row{{"b0103a16a3cc4ee062a2d0ccf61f9617"}},
},
{
Query: "SELECT md5( 'something ' ) ;",
Expected: []sql.Row{{"d23a679e329e8d6c028bbc6692b41dd8"}},
},
{
Query: "SELECT md5( '123456789' ) ;",
Expected: []sql.Row{{"25f9e794323b453885f5181f1b624d0b"}},
},
{
Query: "SELECT md5( 'a group of words' ) ;",
Expected: []sql.Row{{"231d49f0f13a285a2e6c24e0bb47a860"}},
},
{
Query: "SELECT md5( '1234567890123456' ) ;",
Expected: []sql.Row{{"abeac07d3c28c1bef9e730002c753ed4"}},
},
},
},
})
}
testing/generation/function_coverage/output/min_scale_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_MinScale(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "min_scale",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT min_scale( 0::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( -1::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 1::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 2::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( -2::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 5::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 10::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( -10::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 1000::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 2105076::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{int32(34)}},
},
{
Query: "SELECT min_scale( -5184226581::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 8525267290::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT min_scale( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
},
},
})
}
testing/generation/function_coverage/output/mod_test.go
+1832
View File
File diff suppressed because it is too large Load Diff
testing/generation/function_coverage/output/octet_length_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_OctetLength(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "octet_length",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT octet_length( '' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT octet_length( ' ' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT octet_length( '0' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT octet_length( '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT octet_length( 'a' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT octet_length( 'abc' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT octet_length( '123' ) ;",
Expected: []sql.Row{{int32(3)}},
},
{
Query: "SELECT octet_length( 'value' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT octet_length( '12345' ) ;",
Expected: []sql.Row{{int32(5)}},
},
{
Query: "SELECT octet_length( 'something' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT octet_length( ' something' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT octet_length( 'something ' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT octet_length( '123456789' ) ;",
Expected: []sql.Row{{int32(9)}},
},
{
Query: "SELECT octet_length( 'a group of words' ) ;",
Expected: []sql.Row{{int32(16)}},
},
{
Query: "SELECT octet_length( '1234567890123456' ) ;",
Expected: []sql.Row{{int32(16)}},
},
},
},
})
}
testing/generation/function_coverage/output/pi_test.go
+35
View File
@@ -0,0 +1,35 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Pi(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "pi",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT pi( ) ;",
Expected: []sql.Row{{float64(3.141593)}},
},
},
},
})
}
testing/generation/function_coverage/output/radians_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Radians(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "radians",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT radians( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT radians( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.017453)}},
},
{
Query: "SELECT radians( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.017453)}},
},
{
Query: "SELECT radians( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.034907)}},
},
{
Query: "SELECT radians( -2::float8 ) ;",
Expected: []sql.Row{{float64(-0.034907)}},
},
{
Query: "SELECT radians( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.091630)}},
},
{
Query: "SELECT radians( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.189717)}},
},
{
Query: "SELECT radians( -10::float8 ) ;",
Expected: []sql.Row{{float64(-0.174533)}},
},
{
Query: "SELECT radians( 100::float8 ) ;",
Expected: []sql.Row{{float64(1.745329)}},
},
{
Query: "SELECT radians( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(367.400185)}},
},
{
Query: "SELECT radians( 100000::float8 ) ;",
Expected: []sql.Row{{float64(1745.329252)}},
},
{
Query: "SELECT radians( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-20669.585266)}},
},
{
Query: "SELECT radians( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(44074.455404)}},
},
{
Query: "SELECT radians( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-37480660.290339)}},
},
{
Query: "SELECT radians( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(37480660.283187)}},
},
},
},
})
}
testing/generation/function_coverage/output/replace_test.go
+2031
View File
File diff suppressed because it is too large Load Diff
testing/generation/function_coverage/output/reverse_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Reverse(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "reverse",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT reverse( '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT reverse( ' ' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT reverse( '0' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT reverse( '1' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT reverse( 'a' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT reverse( 'abc' ) ;",
Expected: []sql.Row{{"cba"}},
},
{
Query: "SELECT reverse( '123' ) ;",
Expected: []sql.Row{{"321"}},
},
{
Query: "SELECT reverse( 'value' ) ;",
Expected: []sql.Row{{"eulav"}},
},
{
Query: "SELECT reverse( '12345' ) ;",
Expected: []sql.Row{{"54321"}},
},
{
Query: "SELECT reverse( 'something' ) ;",
Expected: []sql.Row{{"gnihtemos"}},
},
{
Query: "SELECT reverse( ' something' ) ;",
Expected: []sql.Row{{"gnihtemos "}},
},
{
Query: "SELECT reverse( 'something ' ) ;",
Expected: []sql.Row{{" gnihtemos"}},
},
{
Query: "SELECT reverse( '123456789' ) ;",
Expected: []sql.Row{{"987654321"}},
},
{
Query: "SELECT reverse( 'a group of words' ) ;",
Expected: []sql.Row{{"sdrow fo puorg a"}},
},
{
Query: "SELECT reverse( '1234567890123456' ) ;",
Expected: []sql.Row{{"6543210987654321"}},
},
},
},
})
}
testing/generation/function_coverage/output/right_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Right(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "right",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT right( '' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '0' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '1' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'abc' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '123' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'value' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '12345' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'something' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' something' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'something ' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '123456789' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a group of words' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '1234567890123456' , 0::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '0' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '1' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a' , -1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'abc' , -1::int4 ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT right( '123' , -1::int4 ) ;",
Expected: []sql.Row{{"23"}},
},
{
Query: "SELECT right( 'value' , -1::int4 ) ;",
Expected: []sql.Row{{"alue"}},
},
{
Query: "SELECT right( '12345' , -1::int4 ) ;",
Expected: []sql.Row{{"2345"}},
},
{
Query: "SELECT right( 'something' , -1::int4 ) ;",
Expected: []sql.Row{{"omething"}},
},
{
Query: "SELECT right( ' something' , -1::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT right( 'something ' , -1::int4 ) ;",
Expected: []sql.Row{{"omething "}},
},
{
Query: "SELECT right( '123456789' , -1::int4 ) ;",
Expected: []sql.Row{{"23456789"}},
},
{
Query: "SELECT right( 'a group of words' , -1::int4 ) ;",
Expected: []sql.Row{{" group of words"}},
},
{
Query: "SELECT right( '1234567890123456' , -1::int4 ) ;",
Expected: []sql.Row{{"234567890123456"}},
},
{
Query: "SELECT right( '' , 1::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 1::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 1::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 1::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 1::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 1::int4 ) ;",
Expected: []sql.Row{{"c"}},
},
{
Query: "SELECT right( '123' , 1::int4 ) ;",
Expected: []sql.Row{{"3"}},
},
{
Query: "SELECT right( 'value' , 1::int4 ) ;",
Expected: []sql.Row{{"e"}},
},
{
Query: "SELECT right( '12345' , 1::int4 ) ;",
Expected: []sql.Row{{"5"}},
},
{
Query: "SELECT right( 'something' , 1::int4 ) ;",
Expected: []sql.Row{{"g"}},
},
{
Query: "SELECT right( ' something' , 1::int4 ) ;",
Expected: []sql.Row{{"g"}},
},
{
Query: "SELECT right( 'something ' , 1::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '123456789' , 1::int4 ) ;",
Expected: []sql.Row{{"9"}},
},
{
Query: "SELECT right( 'a group of words' , 1::int4 ) ;",
Expected: []sql.Row{{"s"}},
},
{
Query: "SELECT right( '1234567890123456' , 1::int4 ) ;",
Expected: []sql.Row{{"6"}},
},
{
Query: "SELECT right( '' , 2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 2::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 2::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 2::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 2::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 2::int4 ) ;",
Expected: []sql.Row{{"bc"}},
},
{
Query: "SELECT right( '123' , 2::int4 ) ;",
Expected: []sql.Row{{"23"}},
},
{
Query: "SELECT right( 'value' , 2::int4 ) ;",
Expected: []sql.Row{{"ue"}},
},
{
Query: "SELECT right( '12345' , 2::int4 ) ;",
Expected: []sql.Row{{"45"}},
},
{
Query: "SELECT right( 'something' , 2::int4 ) ;",
Expected: []sql.Row{{"ng"}},
},
{
Query: "SELECT right( ' something' , 2::int4 ) ;",
Expected: []sql.Row{{"ng"}},
},
{
Query: "SELECT right( 'something ' , 2::int4 ) ;",
Expected: []sql.Row{{"g "}},
},
{
Query: "SELECT right( '123456789' , 2::int4 ) ;",
Expected: []sql.Row{{"89"}},
},
{
Query: "SELECT right( 'a group of words' , 2::int4 ) ;",
Expected: []sql.Row{{"ds"}},
},
{
Query: "SELECT right( '1234567890123456' , 2::int4 ) ;",
Expected: []sql.Row{{"56"}},
},
{
Query: "SELECT right( '' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '0' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '1' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a' , -2::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'abc' , -2::int4 ) ;",
Expected: []sql.Row{{"c"}},
},
{
Query: "SELECT right( '123' , -2::int4 ) ;",
Expected: []sql.Row{{"3"}},
},
{
Query: "SELECT right( 'value' , -2::int4 ) ;",
Expected: []sql.Row{{"lue"}},
},
{
Query: "SELECT right( '12345' , -2::int4 ) ;",
Expected: []sql.Row{{"345"}},
},
{
Query: "SELECT right( 'something' , -2::int4 ) ;",
Expected: []sql.Row{{"mething"}},
},
{
Query: "SELECT right( ' something' , -2::int4 ) ;",
Expected: []sql.Row{{"omething"}},
},
{
Query: "SELECT right( 'something ' , -2::int4 ) ;",
Expected: []sql.Row{{"mething "}},
},
{
Query: "SELECT right( '123456789' , -2::int4 ) ;",
Expected: []sql.Row{{"3456789"}},
},
{
Query: "SELECT right( 'a group of words' , -2::int4 ) ;",
Expected: []sql.Row{{"group of words"}},
},
{
Query: "SELECT right( '1234567890123456' , -2::int4 ) ;",
Expected: []sql.Row{{"34567890123456"}},
},
{
Query: "SELECT right( '' , 5::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 5::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 5::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 5::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 5::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 5::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT right( '123' , 5::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT right( 'value' , 5::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT right( '12345' , 5::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT right( 'something' , 5::int4 ) ;",
Expected: []sql.Row{{"thing"}},
},
{
Query: "SELECT right( ' something' , 5::int4 ) ;",
Expected: []sql.Row{{"thing"}},
},
{
Query: "SELECT right( 'something ' , 5::int4 ) ;",
Expected: []sql.Row{{"hing "}},
},
{
Query: "SELECT right( '123456789' , 5::int4 ) ;",
Expected: []sql.Row{{"56789"}},
},
{
Query: "SELECT right( 'a group of words' , 5::int4 ) ;",
Expected: []sql.Row{{"words"}},
},
{
Query: "SELECT right( '1234567890123456' , 5::int4 ) ;",
Expected: []sql.Row{{"23456"}},
},
{
Query: "SELECT right( '' , 10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 10::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 10::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 10::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 10::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 10::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT right( '123' , 10::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT right( 'value' , 10::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT right( '12345' , 10::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT right( 'something' , 10::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT right( ' something' , 10::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT right( 'something ' , 10::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT right( '123456789' , 10::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT right( 'a group of words' , 10::int4 ) ;",
Expected: []sql.Row{{"p of words"}},
},
{
Query: "SELECT right( '1234567890123456' , 10::int4 ) ;",
Expected: []sql.Row{{"7890123456"}},
},
{
Query: "SELECT right( '' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '0' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '1' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'abc' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '123' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'value' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '12345' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'something' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' something' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'something ' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '123456789' , -10::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a group of words' , -10::int4 ) ;",
Expected: []sql.Row{{" words"}},
},
{
Query: "SELECT right( '1234567890123456' , -10::int4 ) ;",
Expected: []sql.Row{{"123456"}},
},
{
Query: "SELECT right( '' , 100::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 100::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 100::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 100::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 100::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 100::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT right( '123' , 100::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT right( 'value' , 100::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT right( '12345' , 100::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT right( 'something' , 100::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT right( ' something' , 100::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT right( 'something ' , 100::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT right( '123456789' , 100::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT right( 'a group of words' , 100::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT right( '1234567890123456' , 100::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT right( '' , 21050::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 21050::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 21050::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 21050::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 21050::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 21050::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT right( '123' , 21050::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT right( 'value' , 21050::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT right( '12345' , 21050::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT right( 'something' , 21050::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT right( ' something' , 21050::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT right( 'something ' , 21050::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT right( '123456789' , 21050::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT right( 'a group of words' , 21050::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT right( '1234567890123456' , 21050::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT right( '' , 100000::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 100000::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 100000::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 100000::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 100000::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 100000::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT right( '123' , 100000::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT right( 'value' , 100000::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT right( '12345' , 100000::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT right( 'something' , 100000::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT right( ' something' , 100000::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT right( 'something ' , 100000::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT right( '123456789' , 100000::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT right( 'a group of words' , 100000::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT right( '1234567890123456' , 100000::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT right( '' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '0' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '1' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'abc' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '123' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'value' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '12345' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'something' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' something' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'something ' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '123456789' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( 'a group of words' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '1234567890123456' , -1184280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( '' , 2525280::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 2525280::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 2525280::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 2525280::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 2525280::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 2525280::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT right( '123' , 2525280::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT right( 'value' , 2525280::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT right( '12345' , 2525280::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT right( 'something' , 2525280::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT right( ' something' , 2525280::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT right( 'something ' , 2525280::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT right( '123456789' , 2525280::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT right( 'a group of words' , 2525280::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT right( '1234567890123456' , 2525280::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT right( '' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( ' ' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( '0' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( '1' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( 'a' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( 'abc' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( '123' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( 'value' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( '12345' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( 'something' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( ' something' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( 'something ' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( '123456789' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( 'a group of words' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( '1234567890123456' , -2147483648::int4 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT right( '' , 2147483647::int4 ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT right( ' ' , 2147483647::int4 ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT right( '0' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT right( '1' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT right( 'a' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT right( 'abc' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT right( '123' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT right( 'value' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT right( '12345' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT right( 'something' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT right( ' something' , 2147483647::int4 ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT right( 'something ' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT right( '123456789' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT right( 'a group of words' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT right( '1234567890123456' , 2147483647::int4 ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
},
},
})
}
testing/generation/function_coverage/output/rtrim_test.go
+991
View File
@@ -0,0 +1,991 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Rtrim(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "rtrim",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT rtrim( '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '0' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( '123456789' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , '' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , '' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , '' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , '' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , '' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , '' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , '' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , '' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , '' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , '' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , '' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , '' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , '' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , '' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , ' ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '0' , ' ' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , ' ' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , ' ' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , ' ' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , ' ' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , ' ' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , ' ' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , ' ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , ' ' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , ' ' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( '123456789' , ' ' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , ' ' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , ' ' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , '0' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , '0' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , '0' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '1' , '0' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , '0' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , '0' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , '0' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , '0' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , '0' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , '0' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , '0' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , '0' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , '0' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , '0' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , '0' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , '1' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , '1' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , '1' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , '1' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'a' , '1' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , '1' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , '1' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , '1' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , '1' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , '1' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , '1' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , '1' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , '1' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , '1' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , '1' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , 'a' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , 'a' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , 'a' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , 'a' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , 'a' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'abc' , 'a' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , 'a' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , 'a' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , 'a' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , 'a' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , 'a' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , 'a' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , 'a' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , 'a' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , 'a' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , 'abc' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , 'abc' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , 'abc' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'abc' , 'abc' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '123' , 'abc' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , 'abc' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , 'abc' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , 'abc' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , 'abc' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , 'abc' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , 'abc' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , 'abc' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , 'abc' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , '123' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , '123' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'a' , '123' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , '123' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , '123' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'value' , '123' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , '123' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , '123' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , '123' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , '123' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , '123' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , '123' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , '123' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , 'value' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , 'value' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , 'value' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'abc' , 'value' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , 'value' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , 'value' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '12345' , 'value' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , 'value' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , 'value' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , 'value' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , 'value' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , 'value' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , 'value' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , '12345' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , '12345' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'a' , '12345' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , '12345' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'value' , '12345' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , '12345' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'something' , '12345' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , '12345' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , '12345' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , '12345' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , '12345' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , '12345' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , 'something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , 'something' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , 'something' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , 'something' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , 'something' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , 'something' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , 'something' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , 'something' ) ;",
Expected: []sql.Row{{"valu"}},
},
{
Query: "SELECT rtrim( '12345' , 'something' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , 'something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' something' , 'something' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( 'something ' , 'something' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , 'something' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , 'something' ) ;",
Expected: []sql.Row{{"a group of word"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , 'something' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '0' , ' something' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , ' something' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , ' something' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , ' something' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , ' something' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , ' something' ) ;",
Expected: []sql.Row{{"valu"}},
},
{
Query: "SELECT rtrim( '12345' , ' something' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' something' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'something ' , ' something' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '123456789' , ' something' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , ' something' ) ;",
Expected: []sql.Row{{"a group of word"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , ' something' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '0' , 'something ' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , 'something ' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , 'something ' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , 'something ' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , 'something ' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , 'something ' ) ;",
Expected: []sql.Row{{"valu"}},
},
{
Query: "SELECT rtrim( '12345' , 'something ' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' something' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'something ' , 'something ' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '123456789' , 'something ' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , 'something ' ) ;",
Expected: []sql.Row{{"a group of word"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , 'something ' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , '123456789' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , '123456789' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'a' , '123456789' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , '123456789' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'value' , '123456789' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'something' , '123456789' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , '123456789' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , '123456789' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , '123456789' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'a group of words' , '123456789' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , '123456789' ) ;",
Expected: []sql.Row{{"1234567890"}},
},
{
Query: "SELECT rtrim( '' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '0' , 'a group of words' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT rtrim( '1' , 'a group of words' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT rtrim( 'a' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'abc' , 'a group of words' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , 'a group of words' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT rtrim( 'value' , 'a group of words' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , 'a group of words' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT rtrim( 'something' , 'a group of words' ) ;",
Expected: []sql.Row{{"somethin"}},
},
{
Query: "SELECT rtrim( ' something' , 'a group of words' ) ;",
Expected: []sql.Row{{" somethin"}},
},
{
Query: "SELECT rtrim( 'something ' , 'a group of words' ) ;",
Expected: []sql.Row{{"somethin"}},
},
{
Query: "SELECT rtrim( '123456789' , 'a group of words' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT rtrim( 'a group of words' , 'a group of words' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '1234567890123456' , 'a group of words' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
{
Query: "SELECT rtrim( '' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( ' ' , '1234567890123456' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT rtrim( '0' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( '1' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'a' , '1234567890123456' ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT rtrim( 'abc' , '1234567890123456' ) ;",
Expected: []sql.Row{{"abc"}},
},
{
Query: "SELECT rtrim( '123' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'value' , '1234567890123456' ) ;",
Expected: []sql.Row{{"value"}},
},
{
Query: "SELECT rtrim( '12345' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'something' , '1234567890123456' ) ;",
Expected: []sql.Row{{"something"}},
},
{
Query: "SELECT rtrim( ' something' , '1234567890123456' ) ;",
Expected: []sql.Row{{" something"}},
},
{
Query: "SELECT rtrim( 'something ' , '1234567890123456' ) ;",
Expected: []sql.Row{{"something "}},
},
{
Query: "SELECT rtrim( '123456789' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT rtrim( 'a group of words' , '1234567890123456' ) ;",
Expected: []sql.Row{{"a group of words"}},
},
{
Query: "SELECT rtrim( '1234567890123456' , '1234567890123456' ) ;",
Expected: []sql.Row{{""}},
},
},
},
})
}
testing/generation/function_coverage/output/scale_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Scale(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "scale",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT scale( 0::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( -1::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 1::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 2::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( -2::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 5::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 10::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( -10::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 1000::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 2105076::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{int32(34)}},
},
{
Query: "SELECT scale( -5184226581::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 8525267290::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT scale( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{int32(0)}},
},
},
},
})
}
testing/generation/function_coverage/output/set_config_test.go
+85
View File
@@ -0,0 +1,85 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_SetConfig(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "set_config",
Assertions: []ScriptTestAssertion{
{
// non-namespaced, non-system settings result in an error: "unrecognized configuration parameter"
Query: "SELECT set_config('doesnotexist', '42', false);",
ExpectedErr: true,
},
{
Query: "SELECT set_config('', 'bar', false);",
ExpectedErr: true,
},
{
Query: "SELECT set_config(NULL, 'bar', false);",
ExpectedErr: true,
},
{
// Set a system config setting
Query: "SELECT set_config('search_path', '123', false);",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT current_setting('search_path');",
Expected: []sql.Row{{"123"}},
},
{
// Set a user config setting in a custom namespace
Query: "SELECT set_config('mynamespace.var', 'bar', false);",
Expected: []sql.Row{{"bar"}},
},
{
Query: "SELECT current_setting('mynamespace.var');",
Expected: []sql.Row{{"bar"}},
},
{
// Only text values are supported
Query: "SELECT set_config('myvars.boo', 3.14159, false);",
ExpectedErr: true,
},
{
// All settings must be text
Query: "SELECT set_config('myvars.boo', 3.14159::text, false);",
Expected: []sql.Row{{"3.14159"}},
},
{
Query: "SELECT current_setting('myvars.boo');",
Expected: []sql.Row{{"3.14159"}},
},
{
// A NULL value is turned into the empty string
Query: "SELECT set_config('myvars.nullval', NULL, false);",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT current_setting('myvars.nullval');",
Expected: []sql.Row{{""}},
},
},
},
})
}
testing/generation/function_coverage/output/sign_test.go
+151
View File
@@ -0,0 +1,151 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Sign(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "sign",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT sign( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT sign( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT sign( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( 2::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( -2::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT sign( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( -10::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT sign( 100::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( 100000::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT sign( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT sign( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sign( 0::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT sign( -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT sign( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT sign( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT sign( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT sign( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT sign( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT sign( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
},
},
})
}
testing/generation/function_coverage/output/sin_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Sin(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "sin",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT sin( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT sin( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.841471)}},
},
{
Query: "SELECT sin( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.841471)}},
},
{
Query: "SELECT sin( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.909297)}},
},
{
Query: "SELECT sin( -2::float8 ) ;",
Expected: []sql.Row{{float64(-0.909297)}},
},
{
Query: "SELECT sin( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-0.858934)}},
},
{
Query: "SELECT sin( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(-0.992126)}},
},
{
Query: "SELECT sin( -10::float8 ) ;",
Expected: []sql.Row{{float64(0.544021)}},
},
{
Query: "SELECT sin( 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.506366)}},
},
{
Query: "SELECT sin( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.971711)}},
},
{
Query: "SELECT sin( 100000::float8 ) ;",
Expected: []sql.Row{{float64(0.035749)}},
},
{
Query: "SELECT sin( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-0.100392)}},
},
{
Query: "SELECT sin( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.847360)}},
},
{
Query: "SELECT sin( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(0.971310)}},
},
{
Query: "SELECT sin( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-0.985645)}},
},
},
},
})
}
testing/generation/function_coverage/output/sind_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Sind(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "sind",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT sind( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT sind( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.017452)}},
},
{
Query: "SELECT sind( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.017452)}},
},
{
Query: "SELECT sind( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.034899)}},
},
{
Query: "SELECT sind( -2::float8 ) ;",
Expected: []sql.Row{{float64(-0.034899)}},
},
{
Query: "SELECT sind( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.091502)}},
},
{
Query: "SELECT sind( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.188581)}},
},
{
Query: "SELECT sind( -10::float8 ) ;",
Expected: []sql.Row{{float64(-0.173648)}},
},
{
Query: "SELECT sind( 100::float8 ) ;",
Expected: []sql.Row{{float64(0.984808)}},
},
{
Query: "SELECT sind( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(0.165392)}},
},
{
Query: "SELECT sind( 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.984808)}},
},
{
Query: "SELECT sind( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(0.866025)}},
},
{
Query: "SELECT sind( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-0.868450)}},
},
{
Query: "SELECT sind( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-0.788011)}},
},
{
Query: "SELECT sind( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(0.792394)}},
},
},
},
})
}
testing/generation/function_coverage/output/sinh_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Sinh(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "sinh",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT sinh( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT sinh( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.175201)}},
},
{
Query: "SELECT sinh( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.175201)}},
},
{
Query: "SELECT sinh( 2::float8 ) ;",
Expected: []sql.Row{{float64(3.626860)}},
},
{
Query: "SELECT sinh( -2::float8 ) ;",
Expected: []sql.Row{{float64(-3.626860)}},
},
{
Query: "SELECT sinh( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(95.280510)}},
},
{
Query: "SELECT sinh( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(26287.605126)}},
},
{
Query: "SELECT sinh( -10::float8 ) ;",
Expected: []sql.Row{{float64(-11013.232875)}},
},
{
Query: "SELECT sinh( 100::float8 ) ;",
Expected: []sql.Row{{float64(13440585709080678047126700217981451777343488.000000)}},
},
{
Query: "SELECT sinh( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT sinh( 100000::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT sinh( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-Inf)}},
},
{
Query: "SELECT sinh( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
{
Query: "SELECT sinh( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-Inf)}},
},
{
Query: "SELECT sinh( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(+Inf)}},
},
},
},
})
}
testing/generation/function_coverage/output/split_part_test.go
+2031
View File
File diff suppressed because it is too large Load Diff
testing/generation/function_coverage/output/sqrt_test.go
+151
View File
@@ -0,0 +1,151 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Sqrt(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "sqrt",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT sqrt( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT sqrt( -1::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT sqrt( 2::float8 ) ;",
Expected: []sql.Row{{float64(1.414214)}},
},
{
Query: "SELECT sqrt( -2::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(2.291288)}},
},
{
Query: "SELECT sqrt( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(3.296968)}},
},
{
Query: "SELECT sqrt( -10::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 100::float8 ) ;",
Expected: []sql.Row{{float64(10.000000)}},
},
{
Query: "SELECT sqrt( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(145.087835)}},
},
{
Query: "SELECT sqrt( 100000::float8 ) ;",
Expected: []sql.Row{{float64(316.227766)}},
},
{
Query: "SELECT sqrt( -1184280::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(1589.113048)}},
},
{
Query: "SELECT sqrt( -2147483648::float8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(46340.950007)}},
},
{
Query: "SELECT sqrt( 0::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT sqrt( -1::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1.000000000000000")}},
},
{
Query: "SELECT sqrt( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("1.414213562373095")}},
},
{
Query: "SELECT sqrt( -2::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("2.236067977499790")}},
},
{
Query: "SELECT sqrt( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("3.162277660168379")}},
},
{
Query: "SELECT sqrt( -10::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("31.622776601683793")}},
},
{
Query: "SELECT sqrt( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("1450.8880039479271")}},
},
{
Query: "SELECT sqrt( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("10000.0000117293116104028950144216538400")}},
},
{
Query: "SELECT sqrt( -5184226581::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("92332.37400825346")}},
},
{
Query: "SELECT sqrt( -79223372036854775808::numeric ) ;",
ExpectedErr: true,
},
{
Query: "SELECT sqrt( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("8900751206.3226874")}},
},
},
},
})
}
testing/generation/function_coverage/output/strpos_test.go
+931
View File
@@ -0,0 +1,931 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Strpos(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "strpos",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT strpos( '' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( ' ' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '0' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '1' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'a' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'abc' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '123' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'value' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '12345' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'something' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( ' something' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'something ' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '123456789' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'a group of words' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '1234567890123456' , '' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , ' ' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '0' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , ' ' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'something ' , ' ' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT strpos( '123456789' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , ' ' ) ;",
Expected: []sql.Row{{int32(2)}},
},
{
Query: "SELECT strpos( '1234567890123456' , ' ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , '0' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '1' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , '0' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , '0' ) ;",
Expected: []sql.Row{{int32(10)}},
},
{
Query: "SELECT strpos( '' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'a' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'value' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'something' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'a group of words' , '1' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , '1' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , 'a' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'abc' , 'a' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '123' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , 'a' ) ;",
Expected: []sql.Row{{int32(2)}},
},
{
Query: "SELECT strpos( '12345' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , 'a' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '1234567890123456' , 'a' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , 'abc' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '123' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , 'abc' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , '123' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'value' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , '123' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'something' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , '123' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'a group of words' , '123' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , '123' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , 'value' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '12345' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , 'value' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , '12345' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'something' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , '12345' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'a group of words' , '12345' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , '12345' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , 'something' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( ' something' , 'something' ) ;",
Expected: []sql.Row{{int32(2)}},
},
{
Query: "SELECT strpos( 'something ' , 'something' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '123456789' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , 'something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , ' something' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'something ' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , ' something' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , 'something ' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '123456789' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , 'something ' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , '123456789' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( 'a group of words' , '123456789' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , '123456789' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(1)}},
},
{
Query: "SELECT strpos( '1234567890123456' , 'a group of words' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' ' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '0' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'abc' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'value' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '12345' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( ' something' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'something ' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '123456789' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( 'a group of words' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(0)}},
},
{
Query: "SELECT strpos( '1234567890123456' , '1234567890123456' ) ;",
Expected: []sql.Row{{int32(1)}},
},
},
},
})
}
testing/generation/function_coverage/output/substr_test.go
+2931
View File
File diff suppressed because it is too large Load Diff
testing/generation/function_coverage/output/tan_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Tan(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "tan",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT tan( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT tan( -1::float8 ) ;",
Expected: []sql.Row{{float64(-1.557408)}},
},
{
Query: "SELECT tan( 1::float8 ) ;",
Expected: []sql.Row{{float64(1.557408)}},
},
{
Query: "SELECT tan( 2::float8 ) ;",
Expected: []sql.Row{{float64(-2.185040)}},
},
{
Query: "SELECT tan( -2::float8 ) ;",
Expected: []sql.Row{{float64(2.185040)}},
},
{
Query: "SELECT tan( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(-1.677326)}},
},
{
Query: "SELECT tan( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(7.921512)}},
},
{
Query: "SELECT tan( -10::float8 ) ;",
Expected: []sql.Row{{float64(-0.648361)}},
},
{
Query: "SELECT tan( 100::float8 ) ;",
Expected: []sql.Row{{float64(-0.587214)}},
},
{
Query: "SELECT tan( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-4.114420)}},
},
{
Query: "SELECT tan( 100000::float8 ) ;",
Expected: []sql.Row{{float64(-0.035772)}},
},
{
Query: "SELECT tan( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-0.100902)}},
},
{
Query: "SELECT tan( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(-1.595725)}},
},
{
Query: "SELECT tan( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(4.084289)}},
},
{
Query: "SELECT tan( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(5.838073)}},
},
},
},
})
}
testing/generation/function_coverage/output/tand_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Tand(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "tand",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT tand( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT tand( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.017455)}},
},
{
Query: "SELECT tand( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.017455)}},
},
{
Query: "SELECT tand( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.034921)}},
},
{
Query: "SELECT tand( -2::float8 ) ;",
Expected: []sql.Row{{float64(-0.034921)}},
},
{
Query: "SELECT tand( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.091887)}},
},
{
Query: "SELECT tand( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(0.192027)}},
},
{
Query: "SELECT tand( -10::float8 ) ;",
Expected: []sql.Row{{float64(-0.176327)}},
},
{
Query: "SELECT tand( 100::float8 ) ;",
Expected: []sql.Row{{float64(-5.671282)}},
},
{
Query: "SELECT tand( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(-0.167701)}},
},
{
Query: "SELECT tand( 100000::float8 ) ;",
Expected: []sql.Row{{float64(-5.671282)}},
},
{
Query: "SELECT tand( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1.732051)}},
},
{
Query: "SELECT tand( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(1.751695)}},
},
{
Query: "SELECT tand( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(1.279942)}},
},
{
Query: "SELECT tand( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(-1.298984)}},
},
},
},
})
}
testing/generation/function_coverage/output/tanh_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Tanh(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "tanh",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT tanh( 0::float8 ) ;",
Expected: []sql.Row{{float64(0.000000)}},
},
{
Query: "SELECT tanh( -1::float8 ) ;",
Expected: []sql.Row{{float64(-0.761594)}},
},
{
Query: "SELECT tanh( 1::float8 ) ;",
Expected: []sql.Row{{float64(0.761594)}},
},
{
Query: "SELECT tanh( 2::float8 ) ;",
Expected: []sql.Row{{float64(0.964028)}},
},
{
Query: "SELECT tanh( -2::float8 ) ;",
Expected: []sql.Row{{float64(-0.964028)}},
},
{
Query: "SELECT tanh( 5.25::float8 ) ;",
Expected: []sql.Row{{float64(0.999945)}},
},
{
Query: "SELECT tanh( 10.87::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT tanh( -10::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT tanh( 100::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT tanh( 21050.48::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT tanh( 100000::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT tanh( -1184280::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT tanh( 2525280.279::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
{
Query: "SELECT tanh( -2147483648::float8 ) ;",
Expected: []sql.Row{{float64(-1.000000)}},
},
{
Query: "SELECT tanh( 2147483647.59024::float8 ) ;",
Expected: []sql.Row{{float64(1.000000)}},
},
},
},
})
}
testing/generation/function_coverage/output/to_char_test.go
+37
View File
@@ -0,0 +1,37 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_ToChar(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "to_char",
Assertions: []ScriptTestAssertion{
{
Query: `SELECT to_char(timestamp '2021-09-15 21:43:56.123456789', 'YYYY-MM-DD HH24:MI:SS.MS');`,
Expected: []sql.Row{
{"2021-09-15 21:43:56.123"},
},
},
},
},
})
}
testing/generation/function_coverage/output/to_hex_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_ToHex(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "to_hex",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT to_hex( 0::int8 ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT to_hex( -1::int8 ) ;",
Expected: []sql.Row{{"ffffffffffffffff"}},
},
{
Query: "SELECT to_hex( 1::int8 ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT to_hex( 2::int8 ) ;",
Expected: []sql.Row{{"2"}},
},
{
Query: "SELECT to_hex( -2::int8 ) ;",
Expected: []sql.Row{{"fffffffffffffffe"}},
},
{
Query: "SELECT to_hex( 5::int8 ) ;",
Expected: []sql.Row{{"5"}},
},
{
Query: "SELECT to_hex( 10::int8 ) ;",
Expected: []sql.Row{{"a"}},
},
{
Query: "SELECT to_hex( -10::int8 ) ;",
Expected: []sql.Row{{"fffffffffffffff6"}},
},
{
Query: "SELECT to_hex( 1000::int8 ) ;",
Expected: []sql.Row{{"3e8"}},
},
{
Query: "SELECT to_hex( 2105076::int8 ) ;",
Expected: []sql.Row{{"201ef4"}},
},
{
Query: "SELECT to_hex( 100000000::int8 ) ;",
Expected: []sql.Row{{"5f5e100"}},
},
{
Query: "SELECT to_hex( -5184226581::int8 ) ;",
Expected: []sql.Row{{"fffffffecafefaeb"}},
},
{
Query: "SELECT to_hex( 8525267290::int8 ) ;",
Expected: []sql.Row{{"1fc25415a"}},
},
{
Query: "SELECT to_hex( -9223372036854775808::int8 ) ;",
ExpectedErr: true,
},
{
Query: "SELECT to_hex( 9223372036854775807::int8 ) ;",
Expected: []sql.Row{{"7fffffffffffffff"}},
},
},
},
})
}
testing/generation/function_coverage/output/trim_scale_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_TrimScale(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "trim_scale",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT trim_scale( 0::numeric ) ;",
Expected: []sql.Row{{Numeric("0")}},
},
{
Query: "SELECT trim_scale( -1::numeric ) ;",
Expected: []sql.Row{{Numeric("-1")}},
},
{
Query: "SELECT trim_scale( 1::numeric ) ;",
Expected: []sql.Row{{Numeric("1")}},
},
{
Query: "SELECT trim_scale( 2::numeric ) ;",
Expected: []sql.Row{{Numeric("2")}},
},
{
Query: "SELECT trim_scale( -2::numeric ) ;",
Expected: []sql.Row{{Numeric("-2")}},
},
{
Query: "SELECT trim_scale( 5::numeric ) ;",
Expected: []sql.Row{{Numeric("5")}},
},
{
Query: "SELECT trim_scale( 10::numeric ) ;",
Expected: []sql.Row{{Numeric("10")}},
},
{
Query: "SELECT trim_scale( -10::numeric ) ;",
Expected: []sql.Row{{Numeric("-10")}},
},
{
Query: "SELECT trim_scale( 1000::numeric ) ;",
Expected: []sql.Row{{Numeric("1000")}},
},
{
Query: "SELECT trim_scale( 2105076::numeric ) ;",
Expected: []sql.Row{{Numeric("2105076")}},
},
{
Query: "SELECT trim_scale( 100000000.2345862323456346511423652312416532::numeric ) ;",
Expected: []sql.Row{{Numeric("100000000.2345862323456346511423652312416532")}},
},
{
Query: "SELECT trim_scale( -5184226581::numeric ) ;",
Expected: []sql.Row{{Numeric("-5184226581")}},
},
{
Query: "SELECT trim_scale( 8525267290::numeric ) ;",
Expected: []sql.Row{{Numeric("8525267290")}},
},
{
Query: "SELECT trim_scale( -79223372036854775808::numeric ) ;",
Expected: []sql.Row{{Numeric("-79223372036854775808")}},
},
{
Query: "SELECT trim_scale( 79223372036854775807::numeric ) ;",
Expected: []sql.Row{{Numeric("79223372036854775807")}},
},
},
},
})
}
testing/generation/function_coverage/output/trunc_test.go
+1053
View File
File diff suppressed because it is too large Load Diff
testing/generation/function_coverage/output/upper_test.go
+91
View File
@@ -0,0 +1,91 @@
// Copyright 2024 Dolthub, Inc.
//
// Licensed 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 output
import (
"testing"
"github.com/dolthub/go-mysql-server/sql"
)
func Test_Upper(t *testing.T) {
RunScripts(t, []ScriptTest{
{
Name: "upper",
Assertions: []ScriptTestAssertion{
{
Query: "SELECT upper( '' ) ;",
Expected: []sql.Row{{""}},
},
{
Query: "SELECT upper( ' ' ) ;",
Expected: []sql.Row{{" "}},
},
{
Query: "SELECT upper( '0' ) ;",
Expected: []sql.Row{{"0"}},
},
{
Query: "SELECT upper( '1' ) ;",
Expected: []sql.Row{{"1"}},
},
{
Query: "SELECT upper( 'a' ) ;",
Expected: []sql.Row{{"A"}},
},
{
Query: "SELECT upper( 'abc' ) ;",
Expected: []sql.Row{{"ABC"}},
},
{
Query: "SELECT upper( '123' ) ;",
Expected: []sql.Row{{"123"}},
},
{
Query: "SELECT upper( 'value' ) ;",
Expected: []sql.Row{{"VALUE"}},
},
{
Query: "SELECT upper( '12345' ) ;",
Expected: []sql.Row{{"12345"}},
},
{
Query: "SELECT upper( 'something' ) ;",
Expected: []sql.Row{{"SOMETHING"}},
},
{
Query: "SELECT upper( ' something' ) ;",
Expected: []sql.Row{{" SOMETHING"}},
},
{
Query: "SELECT upper( 'something ' ) ;",
Expected: []sql.Row{{"SOMETHING "}},
},
{
Query: "SELECT upper( '123456789' ) ;",
Expected: []sql.Row{{"123456789"}},
},
{
Query: "SELECT upper( 'a group of words' ) ;",
Expected: []sql.Row{{"A GROUP OF WORDS"}},
},
{
Query: "SELECT upper( '1234567890123456' ) ;",
Expected: []sql.Row{{"1234567890123456"}},
},
},
},
})
}
testing/generation/function_coverage/output/width_bucket_test.go
+4032
View File
File diff suppressed because it is too large Load Diff