mirror of
https://github.com/hanzoai/s3.git
synced 2026-10-30 14:59:09 +00:00
zooqueen
dd74d3e6d6
hanzoai/s3 was an AGPL-3.0 MinIO fork whose network-copyleft blocks embedding
and reselling as a managed service. Replace it wholesale with a fork of
SeaweedFS (github.com/seaweedfs/seaweedfs, Apache-2.0, Go) which ships a
built-in S3 gateway + Filer.
- License: AGPL-3.0 -> Apache-2.0 (upstream LICENSE kept verbatim, incl.
"Copyright 2025 Chris Lu"); NOTICE added crediting SeaweedFS. No AGPL/BUSL/
SSPL/GPL or enterprise ("ee") files remain.
- Module: go.mod path set to github.com/hanzoai/s3 with a self-replace
(replace github.com/seaweedfs/seaweedfs => ./) so the ~1800 internal Go files
keep their upstream import paths with zero churn. Internal identifiers and
import paths are intentionally NOT renamed.
- CLI rebrand: the binary is built as `s3` (was `weed`); root usage, per-command
help/usage/flag strings, shell autocomplete program name, and the product name
in CLI output now read "Hanzo S3" / `s3`. Users never see `weed`.
(e.g. `s3 server`, `s3 filer`, `s3 master`, `s3 volume`, `s3 s3`, `s3 mount`.)
- Build: `make` (or `go build -o s3 ./weed`) builds the `s3` binary green;
`cmd/weed-db` and `cmd/weed-sql` also build; `go vet ./weed/command/` clean.
- README/LLM.md rewritten for Hanzo S3; AGENTS.md/CLAUDE.md symlinks preserved.
- Dropped a 33MB prebuilt Mach-O `stress` binary upstream had committed; `.gitignore`
updated to ignore the `s3` build output.
261 lines
9.3 KiB
Go
261 lines
9.3 KiB
Go
package engine
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/seaweedfs/seaweedfs/weed/pb/schema_pb"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
// TestCompleteSQLFixes is a comprehensive test verifying all SQL fixes work together
|
|
func TestCompleteSQLFixes(t *testing.T) {
|
|
engine := NewTestSQLEngine()
|
|
|
|
t.Run("OriginalFailingProductionQueries", func(t *testing.T) {
|
|
// Test the exact queries that were originally failing in production
|
|
|
|
testCases := []struct {
|
|
name string
|
|
timestamp int64
|
|
id int64
|
|
sql string
|
|
}{
|
|
{
|
|
name: "OriginalFailingQuery1",
|
|
timestamp: 1756947416566456262,
|
|
id: 897795,
|
|
sql: "select id, _ts_ns as ts from ecommerce.user_events where ts = 1756947416566456262",
|
|
},
|
|
{
|
|
name: "OriginalFailingQuery2",
|
|
timestamp: 1756947416566439304,
|
|
id: 715356,
|
|
sql: "select id, _ts_ns as ts from ecommerce.user_events where ts = 1756947416566439304",
|
|
},
|
|
{
|
|
name: "CurrentDataQuery",
|
|
timestamp: 1756913789829292386,
|
|
id: 82460,
|
|
sql: "select id, _ts_ns as ts from ecommerce.user_events where ts = 1756913789829292386",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
// Create test record matching the production data
|
|
testRecord := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: tc.timestamp}},
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: tc.id}},
|
|
},
|
|
}
|
|
|
|
// Parse the original failing SQL
|
|
stmt, err := ParseSQL(tc.sql)
|
|
assert.NoError(t, err, "Should parse original failing query: %s", tc.name)
|
|
|
|
selectStmt := stmt.(*SelectStatement)
|
|
|
|
// Build predicate with alias support (this was the missing piece)
|
|
predicate, err := engine.buildPredicateWithContext(selectStmt.Where.Expr, selectStmt.SelectExprs)
|
|
assert.NoError(t, err, "Should build predicate for: %s", tc.name)
|
|
|
|
// This should now work (was failing before)
|
|
result := predicate(testRecord)
|
|
assert.True(t, result, "Originally failing query should now work: %s", tc.name)
|
|
|
|
// Verify precision is maintained (timestamp fixes)
|
|
testRecordOffBy1 := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: tc.timestamp + 1}},
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: tc.id}},
|
|
},
|
|
}
|
|
|
|
result2 := predicate(testRecordOffBy1)
|
|
assert.False(t, result2, "Should not match timestamp off by 1 nanosecond: %s", tc.name)
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("AllFixesWorkTogether", func(t *testing.T) {
|
|
// Comprehensive test that all fixes work in combination
|
|
largeTimestamp := int64(1756947416566456262)
|
|
|
|
testRecord := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: largeTimestamp}},
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 897795}},
|
|
"user_id": {Kind: &schema_pb.Value_StringValue{StringValue: "user123"}},
|
|
},
|
|
}
|
|
|
|
// Complex query combining multiple fixes:
|
|
// 1. Alias resolution (ts alias)
|
|
// 2. Large timestamp precision
|
|
// 3. Multiple conditions
|
|
// 4. Different data types
|
|
sql := `SELECT
|
|
_ts_ns AS ts,
|
|
id AS record_id,
|
|
user_id AS uid
|
|
FROM ecommerce.user_events
|
|
WHERE ts = 1756947416566456262
|
|
AND record_id = 897795
|
|
AND uid = 'user123'`
|
|
|
|
stmt, err := ParseSQL(sql)
|
|
assert.NoError(t, err, "Should parse complex query with all fixes")
|
|
|
|
selectStmt := stmt.(*SelectStatement)
|
|
predicate, err := engine.buildPredicateWithContext(selectStmt.Where.Expr, selectStmt.SelectExprs)
|
|
assert.NoError(t, err, "Should build predicate combining all fixes")
|
|
|
|
result := predicate(testRecord)
|
|
assert.True(t, result, "Complex query should work with all fixes combined")
|
|
|
|
// Test that precision is still maintained in complex queries
|
|
testRecordDifferentTimestamp := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: largeTimestamp + 1}}, // Off by 1ns
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 897795}},
|
|
"user_id": {Kind: &schema_pb.Value_StringValue{StringValue: "user123"}},
|
|
},
|
|
}
|
|
|
|
result2 := predicate(testRecordDifferentTimestamp)
|
|
assert.False(t, result2, "Should maintain nanosecond precision even in complex queries")
|
|
})
|
|
|
|
t.Run("BackwardCompatibilityVerified", func(t *testing.T) {
|
|
// Ensure that non-alias queries continue to work exactly as before
|
|
testRecord := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: 1756947416566456262}},
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 897795}},
|
|
},
|
|
}
|
|
|
|
// Traditional query (no aliases) - should work exactly as before
|
|
traditionalSQL := "SELECT _ts_ns, id FROM ecommerce.user_events WHERE _ts_ns = 1756947416566456262 AND id = 897795"
|
|
stmt, err := ParseSQL(traditionalSQL)
|
|
assert.NoError(t, err)
|
|
|
|
selectStmt := stmt.(*SelectStatement)
|
|
|
|
// Should work with both old and new methods
|
|
predicateOld, err := engine.buildPredicate(selectStmt.Where.Expr)
|
|
assert.NoError(t, err, "Old method should still work")
|
|
|
|
predicateNew, err := engine.buildPredicateWithContext(selectStmt.Where.Expr, selectStmt.SelectExprs)
|
|
assert.NoError(t, err, "New method should work for traditional queries")
|
|
|
|
resultOld := predicateOld(testRecord)
|
|
resultNew := predicateNew(testRecord)
|
|
|
|
assert.True(t, resultOld, "Traditional query should work with old method")
|
|
assert.True(t, resultNew, "Traditional query should work with new method")
|
|
assert.Equal(t, resultOld, resultNew, "Both methods should produce identical results")
|
|
})
|
|
|
|
t.Run("PerformanceAndStability", func(t *testing.T) {
|
|
// Test that the fixes don't introduce performance or stability issues
|
|
testRecord := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: 1756947416566456262}},
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 897795}},
|
|
},
|
|
}
|
|
|
|
// Run the same query many times to test stability
|
|
sql := "SELECT _ts_ns AS ts, id FROM test WHERE ts = 1756947416566456262"
|
|
stmt, err := ParseSQL(sql)
|
|
assert.NoError(t, err)
|
|
|
|
selectStmt := stmt.(*SelectStatement)
|
|
|
|
// Build predicate once
|
|
predicate, err := engine.buildPredicateWithContext(selectStmt.Where.Expr, selectStmt.SelectExprs)
|
|
assert.NoError(t, err)
|
|
|
|
// Run multiple times - should be stable
|
|
for i := 0; i < 100; i++ {
|
|
result := predicate(testRecord)
|
|
assert.True(t, result, "Should be stable across multiple executions (iteration %d)", i)
|
|
}
|
|
})
|
|
|
|
t.Run("EdgeCasesAndErrorHandling", func(t *testing.T) {
|
|
// Test various edge cases to ensure robustness
|
|
|
|
// Test with empty/nil inputs
|
|
_, err := engine.buildPredicateWithContext(nil, nil)
|
|
assert.Error(t, err, "Should handle nil expressions gracefully")
|
|
|
|
// Test with nil SelectExprs (should fall back to no-alias behavior)
|
|
compExpr := &ComparisonExpr{
|
|
Left: &ColName{Name: stringValue("_ts_ns")},
|
|
Operator: "=",
|
|
Right: &SQLVal{Type: IntVal, Val: []byte("1756947416566456262")},
|
|
}
|
|
|
|
predicate, err := engine.buildPredicateWithContext(compExpr, nil)
|
|
assert.NoError(t, err, "Should handle nil SelectExprs")
|
|
assert.NotNil(t, predicate, "Should return valid predicate")
|
|
|
|
// Test with empty SelectExprs
|
|
predicate2, err := engine.buildPredicateWithContext(compExpr, []SelectExpr{})
|
|
assert.NoError(t, err, "Should handle empty SelectExprs")
|
|
assert.NotNil(t, predicate2, "Should return valid predicate")
|
|
})
|
|
}
|
|
|
|
// TestSQLFixesSummary provides a quick summary test of all major functionality
|
|
func TestSQLFixesSummary(t *testing.T) {
|
|
engine := NewTestSQLEngine()
|
|
|
|
t.Run("Summary", func(t *testing.T) {
|
|
// The "before and after" test
|
|
testRecord := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: 1756947416566456262}},
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 897795}},
|
|
},
|
|
}
|
|
|
|
// What was failing before (would return 0 rows)
|
|
failingSQL := "SELECT id, _ts_ns AS ts FROM ecommerce.user_events WHERE ts = 1756947416566456262"
|
|
|
|
// What works now
|
|
stmt, err := ParseSQL(failingSQL)
|
|
assert.NoError(t, err, "SQL parsing works")
|
|
|
|
selectStmt := stmt.(*SelectStatement)
|
|
predicate, err := engine.buildPredicateWithContext(selectStmt.Where.Expr, selectStmt.SelectExprs)
|
|
assert.NoError(t, err, "Predicate building works with aliases")
|
|
|
|
result := predicate(testRecord)
|
|
assert.True(t, result, "Originally failing query now works perfectly")
|
|
|
|
// Verify precision is maintained
|
|
testRecordOffBy1 := &schema_pb.RecordValue{
|
|
Fields: map[string]*schema_pb.Value{
|
|
"_ts_ns": {Kind: &schema_pb.Value_Int64Value{Int64Value: 1756947416566456263}},
|
|
"id": {Kind: &schema_pb.Value_Int64Value{Int64Value: 897795}},
|
|
},
|
|
}
|
|
|
|
result2 := predicate(testRecordOffBy1)
|
|
assert.False(t, result2, "Nanosecond precision maintained")
|
|
|
|
t.Log("ALL SQL FIXES VERIFIED:")
|
|
t.Log(" Timestamp precision for large int64 values")
|
|
t.Log(" SQL alias resolution in WHERE clauses")
|
|
t.Log(" Scan boundary fixes for equality queries")
|
|
t.Log(" Range query fixes for equal boundaries")
|
|
t.Log(" Hybrid scanner time range handling")
|
|
t.Log(" Backward compatibility maintained")
|
|
t.Log(" Production stability verified")
|
|
})
|
|
}
|