ISSUE DESCRIPTION [SQL] "expand" projection is always named "value" ignoring "AS"…
- User
ISSUE DESCRIPTION
[SQL] "expand" projection is always named "value" ignoring "AS"
ArcadeDB Server v26.5.1 (build b6d08fee549dd5930303b362223869901aab0fac/1778533954349/main)Running on Linux 6.17.0-29-generic - OpenJDK 64-Bit Server VM 25.0.3-eaUsing
expandin a projection, the result-set contains an property namedvalueinspite an alias of the formAS x:SELECT expand([1,2,3,4]) AS testresults in:
{"result":[{"value":1},{"value":2},{"value":3},{"value":4}]}ADDITIONAL ADVICE
Since you are given a git repository, you can use git commands to simplify your work. For example, if you made a mistake and want to revert your changes, you can use
git checkout <file>to restore the file to its original state. You can also reset all changes in the repository usinggit reset --hardcommand. Additionally, you can usegit stashandgit stash popto temporarily save your changes and restore them later. Finally, you can see the changes that you've made (which will be submitted when you callsubmit) usinggit statusorgit diffcommands. However you don't need to usegit addorgit commitbefore submitting your changes. In fact,submitonly submits currently unstaged changes because it usesgit diffto get the changes that need to be submitted.CHECKLIST
Before submitting your solution, please go over the following checklist and make sure you've done everything:
- If an error was reported in the issue description, I have successfully reproduced it.
- If an error was reported in the issue description, I have confirmed that my fix resolves the error.
- I have thought about edge cases and made sure my fix handles them as well.
- I have run existing tests in the repository that might have been affected by the change I made and confirmed that they pass. I want you to list every bullet from this checklist and write your reasoning for why you think you did it or didn't need to.
Repository has been uploaded and your shell is currently at the repository root. Time to solve the issue!
(Current directory: /arcadedb, current file: none) bash-$
- Assistant
I'll start by exploring the repository to understand the structure and locate the relevant code for the SQL "expand" projection. Let's first see what's in the repository.
- Assistant
Let me find files related to SQL expand and projection.
- Assistant
Let me look for SQL-related files that handle expand projection.
- Assistant
Let me look at the ExpandStep.java and ProjectionItem.java files.
- Assistant
Let me understand the issue. When using
SELECT expand([1,2,3,4]) AS test, the result contains{"value":1}instead of{"test":1}. Let me trace through the code to understand how the projection alias is (or isn't) being used.The
ExpandStepclass processes the expand operation. In thefetchNextmethod, when the element is not aResult,Identifiable, orMap, it creates aResultInternalwith the property name"value". This is the issue - it should use the alias from the projection.Let me look at how the expand is parsed and how the alias gets propagated.
- Assistant
Now let me trace how the expand projection is executed. Let me look at how projections are processed and where the alias gets lost.
- Assistant
Let me look at how
expandis handled in the execution planner and the projection step. - Assistant
Let me look at how the ExpandStep handles the property name. In
fetchNext, I can see it sets"value"as the property name when creating a ResultInternal for non-Result, non-Identifiable, and non-Map values. Let me look at the Projection class to understand how expand projections are processed and what gets passed to ExpandStep. - Assistant
Now I understand the flow. Let me look at how the execution planner handles expand projections:
- Assistant
Let me understand the flow:
SELECT expand([1,2,3,4]) AS testis parsed. The projection isexpand([1,2,3,4]) AS test.- In
ProjectionItem.getExpandContent(), it creates a newProjectionItemwithexpression.getExpandContent()but it doesn't copy the alias. So the aliastestis lost. - The
ExpandStepgets a result from the projection step, which has a single property (the name of which depends on the expression). - In
ExpandStep.fetchNext, when expanding a non-Result, non-Identifiable, non-Map value, it creates aResultInternaland setssetProperty("value", nextElementObj).
So the issue is two-fold:
- The alias
AS testis not being propagated properly. - Even if it were, the
ExpandStephardcodes"value"as the property name.
Let me look at how the expand content flows through the execution plan more carefully.
Let me check what happens in the ExpandStep's fetchNext. It receives a result from the previous step, extracts the single property from it, then creates new results. The property name of the expanded result should be based on the alias.
Wait, actually let me re-read the ExpandStep more carefully. When expanding:
- The previous step produces results with a single property (e.g.,
expand([1,2,3,4])would evaluate[1,2,3,4]and the result would have a property with the name of the expression). fetchNextgets thepropNamefrom the result and extracts theprojValue.- If
projValueis anIterable, it creates an iterator. - For each element in the iterator, if it's a primitive value (like an integer), it creates a
ResultInternaland setssetProperty("value", nextElementObj).
So the issue is that when expanding a collection of primitive values, the
ExpandStepalways names the property "value", ignoring the alias from the original projection.Now, to fix this, we need to pass the alias information to the
ExpandStepso it can use it instead of "value".Let me look at where
ExpandStepis created to see how it's instantiated: - Assistant
Let me look more carefully at the flow. The issue is that when
expandis used withAS alias, the alias is lost. Let me trace the execution path: - Assistant
Let me understand the flow:
- The query
SELECT expand([1,2,3,4]) AS testis parsed into aProjectionwith a singleProjectionItemwhere:
expressionis something likeexpand([1,2,3,4])aliasistest
-
In
optimizeQuery, wheninfo.projection.isExpand()is true:info.expand = trueinfo.projection = info.projection.getExpandContent()which strips theexpand()wrapper3.getExpandContent()inProjectioncallsgetExpandContent()on the first item, which creates a newProjectionItemwith the expression content but does NOT copy the alias!
-
Then in
handleExpand, anExpandStepis chained.
The issue is in
ProjectionItem.getExpandContent()- it doesn't preserve the alias. Let me verify:public ProjectionItem getExpandContent() { final ProjectionItem result = new ProjectionItem(-1); result.setExpression(expression.getExpandContent()); // Ad-hoc support for issue #2965: preserve nested projection when expanding result.nestedProjection = this.nestedProjection; return result; }The alias is not being set here. So when we have
expand([1,2,3,4]) AS test:- The projection item has
alias = test getExpandContent()creates a new item withexpression = [1,2,3,4]butalias = null
Then when the
ExpandStepprocesses the results, it uses"value"as the property name infetchNext.Now let me also look at how the projection step works. The projection would calculate
[1,2,3,4]and create a result with the property name. Since the alias is null, it would use the expression string as the property name.Actually, wait. Let me re-read the flow more carefully. Let me look at
handleProjectionsand how it interacts withhandleExpand. - The query
- Assistant
Now let me understand the flow. When expand is used:
optimizeQuerysetsinfo.expand = trueand replacesinfo.projectionwithinfo.projection.getExpandContent()- this strips theexpand()wrapper but does NOT copy the alias.handleProjectionsis called with the modified projection (without alias)handleExpandis called which chains anExpandStep
So the alias is lost at step 1. The
getExpandContent()method doesn't copy the alias.But wait, I need to understand what ExpandStep actually does. Looking at ExpandStep.fetchNext:
- It gets a Result with one property (the name doesn't matter much)
- It extracts the value of that property
- If the value is an Iterable or Iterator, it iterates over it
- For each primitive element, it creates a ResultInternal with
setProperty("value", nextElementObj)
The "value" is hardcoded. This is the issue - when there's an alias, the property name should be the alias.
But there's a nuance. The expand is supposed to "expand" a collection into individual results. When expanding
[1,2,3,4], each element becomes a separate result. The question is: what should the property name be?Looking at the behavior without alias:
SELECT expand([1,2,3,4])- this should also have "value" as property name since there's no alias. But the issue is specifically about when an alias IS provided.Now, looking at
getExpandContent()inProjectionItem:public ProjectionItem getExpandContent() { final ProjectionItem result = new ProjectionItem(-1); result.setExpression(expression.getExpandContent()); // Ad-hoc support for issue #2965: preserve nested projection when expanding result.nestedProjection = this.nestedProjection; return result; }It doesn't copy the alias. So even if ExpandStep used the alias, it wouldn't be available.
Let me trace through how the projection works:
handleProjectionscreates aProjectionCalculationStepwithinfo.projection- The projection step evaluates the expression and assigns results to property names based on
getProjectionAliasAsString() - Since alias is null after getExpandContent(), the property name will be the expression toString()
Then ExpandStep extracts the value from that single property and expands the collection. For primitive values, it creates new ResultInternal with "value" as the property name.
So there are two approaches:
- Pass the alias to ExpandStep somehow
- In ExpandStep, use the property name from the source result as the property name for expanded elements (instead of hardcoded "value")
Actually, looking more carefully, ExpandStep already extracts
propNamefrom the source result:final String propName = nextAggregateItem.getPropertyNames().iterator().next();But it doesn't use this propName when creating expanded results. Instead, for primitive values, it hardcodes "value".
The cleanest fix would be to:
- In
ExpandStep, use the property name from the source result (or allow an alias to be set) - OR in
ProjectionItem.getExpandContent(), copy the alias to the result
Actually wait, let me re-think. The expand step gets results from the projection step. If
SELECT expand([1,2,3,4]) AS test:After getExpandContent() loses the alias:
- The projection becomes
SELECT [1,2,3,4]with the expression toString as property name - ExpandStep receives a result like
{"[1, 2, 3, 4]": [1,2,3,4]}and expands itAfter the fix in getExpandContent() to preserve the alias: - The projection becomes
SELECT [1,2,3,4] AS test - ExpandStep receives a result like
{"test": [1,2,3,4]}and expands it - But ExpandStep still creates ResultInternal with "value" as property name
So we need BOTH fixes:
- Preserve the alias in
getExpandContent() - In ExpandStep, use the property name from the source result instead of hardcoded "value"
Let me look at ExpandStep more carefully to understand how it creates expanded results.
In
fetchNext:final String propName = nextAggregateItem.getPropertyNames().iterator().next(); final Object projValue = nextAggregateItem.getProperty(propName);Then for each expanded element:
} else { nextElement = new ResultInternal(context.getDatabase()); ((ResultInternal) nextElement).setProperty("value", nextElementObj); }So for primitive values, it hardcodes "value". For other types (Result, Identifiable, Map), it preserves the structure.
The fix should be to use the alias (or the property name from the source result) instead of "value".
Let me think about this more carefully. The ExpandStep doesn't have access to the alias. We need to either:
- Store the alias in ExpandStep
- Or derive it from the source result's property name
Option 2 seems cleaner because the source result's property name already reflects the alias (if the projection correctly uses it).
So the plan is:
- In
ProjectionItem.getExpandContent(), copy the alias to the result - In
ExpandStep.fetchNext(), usepropNameinstead of hardcoded "value" when creating expanded results for primitive values
Let me verify this is correct by checking what happens in the non-aliased case (
SELECT expand([1,2,3,4])):- After getExpandContent() (without fix): expression is
[1,2,3,4], alias is null - Projection creates result with property name
[1,2,3,4](expression toString) - ExpandStep uses this as propName and would use it for expanded results
Hmm, that would change the default behavior from "value" to "[1,2,3,4]" for the non-aliased case. That's not good.
Actually wait, let me re-read the code more carefully. The
getProjectionAliasAsString()returns:public String getProjectionAliasAsString() { return getProjectionAlias().getStringValue(); } public Identifier getProjectionAlias() { if (alias != null) { return alias; } final Identifier result; if (all) { result = new Identifier("*"); } else { result = new Identifier(expression.toString()); } return result; }So when there's no alias, the property name is
expression.toString(). Forexpand([1,2,3,4]), after getExpandContent, expression would be something like[1,2,3,4], and the property name would be[1,2,3,4].Then ExpandStep gets the propName
[1,2,3,4]from the source result. If we use this as the property name for expanded results, we'd get:[{"[1,2,3,4]": 1}, {"[1,2,3,4]": 2}, ...]That's worse than the current "value" behavior. So we need a different approach.
Better approach: in ExpandStep, use the source property name, BUT only for the case when it's not an expression-like name. Or better yet, store the alias in ExpandStep and use it.
Actually, the simplest and most correct approach:
- Add an
aliasfield toExpandStep - Pass the alias when creating the
ExpandStep - In
ExpandStep.fetchNext, use the alias if set, otherwise fall back to "value"
Let me check how ExpandStep is created and how the alias can be passed.
Looking at
handleExpand:private static void handleExpand(final SelectExecutionPlan result, final QueryPlanningInfo info, final CommandContext context) { if (info.expand) { result.chain(new ExpandStep(context)); } }And in
QueryPlanningInfo, we need to store the alias. Let me check if QueryPlanningInfo has relevant fields.Actually, let me think about this differently. Looking at the execution flow:
handleProjectionscreates aProjectionCalculationStepwith the projectionhandleExpandcreates anExpandStep
The ExpandStep operates on the results of the ProjectionCalculationStep. If we fix
getExpandContent()to preserve the alias, the ProjectionCalculationStep would produce results like{"test": [1,2,3,4]}. Then ExpandStep would seepropName = "test"and should use "test" as the property name for expanded primitive values.But for the no-alias case,
propNamewould be the expression string like[1,2,3,4], which we don't want to use as the property name.Wait, actually for the no-alias case,
getExpandContent()returns a ProjectionItem without alias, so the property name would be expression.toString(). But in the current behavior, the property name for expanded elements is "value" regardless. So the current behavior for no-alias is already correct (property name is "value").Hmm, but how does the current code produce "value" for the no-alias case? Let me trace through again...
After
getExpandContent(), the expression is[1,2,3,4]. InhandleProjections, a ProjectionCalculationStep is created. This step evaluates the expression and creates a result withproperty("[1,2,3,4]", [1,2,3,4]).Then ExpandStep receives this result. It extracts
propName = "[1,2,3,4]"andprojValue = [1,2,3,4]. It iterates over the array, and for each primitive value, createsResultInternalwithsetProperty("value", ...). So the original propName is ignored and "value" is used.So the question is: when should we use the alias and when should we use "value"?
I think the correct behavior is:
- If there's an AS alias, use the alias as the property name
- If there's no AS alias, use "value" as the property name
So we need to pass the alias to ExpandStep. Let me look at how to do this.
The cleanest way:
- Store the alias from the original ProjectionItem before calling getExpandContent()
- Pass it to ExpandStep when creating it
- In ExpandStep, use it as the property name for expanded primitive values
Let me check QueryPlanningInfo to see if there's a place to store this.
- Assistant
Let me look at the
QueryPlanningInfoclass to understand how the expand alias could be stored: - Assistant
Let me see the full QueryPlanningInfo class:
- Assistant
Let me trace through how the expand works in the query execution. Let me look at how
getExpandContentworks on expressions: - Assistant
Let me look at the MathExpression to understand how expand works:
- Assistant
Let me look at the
getExpandContentmethod inMathExpressionto understand what it returns. - Assistant
Let me look at
BaseExpressionto understand how expand is parsed: - Assistant
Now let me understand the full picture. The key issue is in
ProjectionItem.getExpandContent()- it doesn't copy the alias. Let me also look at how the alias gets used in the ExpandStep. Let me first check the existing test to understand expected behavior: - Assistant
Now I understand the full picture. Let me trace through the code:
-
SELECT expand([1,2,3,4]) AS testis parsed into aProjectionItemwithexpression=expand([1,2,3,4])andalias=test. -
In
optimizeQuery(),info.projection.isExpand()is true, so:info.expand = trueinfo.projection = info.projection.getExpandContent()— this callsgetExpandContent()which creates a NEWProjectionItemWITHOUT copying the alias!
-
Later,
handleProjections()calculates the projection, and thenhandleExpand()adds anExpandStep. -
In
ExpandStep.fetchNext(), when expanding primitive values, it always creates aResultInternalwithsetProperty("value", nextElementObj).
The issue is:
- The alias is lost in
getExpandContent() ExpandStepalways uses "value" as the property name
I need to:
- Preserve the alias and pass it to
ExpandStep - Use the alias in
ExpandStep.fetchNext()when creating expanded primitive values
Let me first write a reproduction script to confirm the issue:
-
- Assistant
Now let me write a test script to reproduce the issue first:
- Assistant
Now I understand the full problem. Let me trace through the execution path:
SELECT expand([1,2,3,4]) AS testis parsed, creating aProjectionItemwithexpression=expand([1,2,3,4])andalias=test.- In
optimizeQuery(),info.projection.isExpand()returns true, soinfo.expand = trueandinfo.projection = info.projection.getExpandContent(). ProjectionItem.getExpandContent()creates a newProjectionItemWITHOUT copying the alias!- Later
handleExpand()createsExpandStepwithout any alias information. - In
ExpandStep.fetchNext(), when expanding primitive values, it always uses"value"as the property name.
The fix needs two parts:
- Pass the expand alias to
ExpandStep - Use the alias instead of "value" when creating expanded primitive results
Let me first write a test to confirm the issue, then implement the fix:
- Assistant
Let me look at the ExpandParseTest:
- Assistant
Now I understand the issue clearly. Let me trace through the code:
- When
SELECT expand([1,2,3,4]) AS testis parsed, theProjectionItemhasexpression=expand([1,2,3,4])andalias=test. - In
optimizeQuery(),info.projection.isExpand()returns true, so:info.expand = trueinfo.projection = info.projection.getExpandContent()— this strips the expand but the alias is lost inProjectionItem.getExpandContent()!
handleExpand()createsExpandStepwithout any alias info.- In
ExpandStep.fetchNext(), when expanding primitive values, it always uses"value"as the property name.
The fix needs to:
- Pass the alias to
ExpandStep - Use that alias instead of the hardcoded
"value"when creating expanded results for primitives
Let me implement this. First, add the alias field to
ExpandStep: - When
- Assistant
Let me use the open command correctly.
- Assistant
Now I need to understand the full flow. Let me look at the
optimizeQuerymethod more carefully and think about the fix: - Assistant
Now I understand the full picture. The issue is:
- When
expand()is used withAS alias, the alias information is lost because:ProjectionItem.getExpandContent()does not copy the aliasExpandStephardcodes"value"as the property name for primitive values
The fix needs to:
- Preserve the alias through the expand content extraction
- Pass the alias to
ExpandStepso it uses the correct property name
Let me look at how the expand content flows through:
- In
optimizeQuery(),info.projection.getExpandContent()is called which strips the expand wrapper but loses the alias - Then
handleProjections()creates aProjectionCalculationStepwith the expand content - Then
handleExpand()creates anExpandStep
The fix approach:
- Store the expand alias in
QueryPlanningInfowhen extracting expand content - Pass it to
ExpandStepwhen creating it - In
ExpandStep, use the alias when creating primitive value results
Let me implement this step by step.
- When
- Assistant
Now I have a clear understanding of the issue. Let me implement the fix:
- Add an
expandAliasfield toQueryPlanningInfoto preserve the alias - Save the alias in
optimizeQuery()before stripping expand - Add an alias parameter to
ExpandStepconstructor - Use the alias in
ExpandStep.fetchNext()for primitive values - Pass the alias in
handleExpand()
Let me start with the changes:
- Add an
- Assistant
Let me open the file first and then edit it:
- Assistant
Now I understand the issue. Let me look at what approach is cleanest. The issue is:
SELECT expand([1,2,3,4]) AS test- the aliastestis lost whengetExpandContent()strips the expandExpandStepalways uses"value"for primitive values
The cleanest fix is to pass the alias to
ExpandStepand use it for the property name. Let me implement:- Add
expandAliasfield toQueryPlanningInfo - Store alias in
optimizeQuery()when stripping expand - Pass alias to
ExpandStepinhandleExpand() - Use alias in
ExpandStep.fetchNext()for primitive values
- Assistant
Let me try a different approach to editing. Maybe I need to use a different syntax.
- Assistant
Let me use sed to make the modifications:
- Assistant
Now I need to also update the copy() method to include expandAlias. Let me first check the current state of the file:
- Assistant
Wait, let me reconsider the approach. Instead of passing through QueryPlanningInfo, a simpler approach would be to:
- Copy the alias in
ProjectionItem.getExpandContent()so the alias is preserved - Then in
ExpandStep.fetchNext(), use the property name from the source result as the key for primitive values instead of hardcoded "value"
Let me revert the QueryPlanningInfo change and take this simpler approach:
- Copy the alias in
- Assistant
Let me think about this more carefully. The simplest and most direct fix is:
- Store the expand alias in
ExpandStepdirectly - Pass it through from the planner
Let me implement this approach properly:
- Store the expand alias in
- Assistant
Let me implement the fix step by step. First, I'll add the
expandAliasfield toQueryPlanningInfo: - Assistant
Now I need to update the copy() method to include expandAlias:
- Assistant
I need to add
result.expandAlias = this.expandAlias;after line 88. - Assistant
Now let me update the
optimizeQuerymethod to store the alias before getting expand content: - Assistant
I need to store the alias before getting expand content. Let me modify the
optimizeQuerymethod: - Assistant
Let me verify the change:
- Assistant
I see there's a duplicate closing brace. Let me fix it:
- Assistant
I see there's a duplicate closing brace on line 706. Let me fix it:
- Assistant
Let me verify the fix:
- Assistant
Now let me update the
handleExpandmethod to pass the alias toExpandStep: - Assistant
Let me modify the
handleExpandmethod to pass the alias: - Assistant
Let me verify:
- Assistant
There's an extra closing brace. Let me fix that:
- Assistant
Let me verify:
- Assistant
Now I need to update
ExpandStepto accept and use the alias. Let me update the constructor and thefetchNextmethod: - Assistant
Now I need to add an alias field to ExpandStep and modify the constructor to accept it. Then I need to use it in fetchNext when creating ResultInternal for primitive values.
Let me also check the existing constructor to make sure I keep backward compatibility.
- Assistant
Good, there's only one call to
new ExpandStep. Let me now modify the ExpandStep class: - Assistant
Now I need to update the line that sets the property name "value" to use the alias if available:
- Assistant
I need to change line 106 to use the alias if available. Let me see the context:
- Assistant
I need to change line 106 to use
expandAliasif it's set, otherwise fall back to "value". - Assistant
Let me verify the changes:
- Assistant
Let me verify the entire ExpandStep file looks correct:
- Assistant
Let me verify the QueryPlanningInfo.copy() method includes expandAlias:
- Assistant
Now let me try to compile the code to make sure it compiles correctly:
- Assistant
Now let me run the existing expand tests to make sure I haven't broken anything:
- Assistant
I need to check the current directory and adjust the path.
- Assistant
OK, the current directory is /arcadedb/engine. Let me run the tests from there.
- Assistant
Tests passed. Let me also run the ExpandParseTest:
- Assistant
Good, all tests pass. Now let me write a quick test to verify the fix works for the specific issue. Let me also run the UnwindExpandStepTest:
- Assistant
Good, all tests pass. Now let me write a quick test to verify the fix works for the specific issue. Let me create a simple test script:
- Assistant
Let me instead write a proper test within the existing test infrastructure. I'll create a temporary test file:
- Assistant
I need to fix the path since we're already in the engine directory:
- Assistant
Now let me run the test:
- Assistant
I need to fix the test -
result.hasNext()returns a boolean, not a predicate. Let me fix the ambiguous assertion: - Assistant
Both tests pass. Now let me remove the test file since the instructions say not to modify or add tests. Let me also run a broader set of related tests to make sure nothing is broken.
- Assistant
Let me also run a broader set of related tests to make sure nothing is broken:
- Assistant
Let me also run the ProjectionTest:
- Assistant
Let me also run the SQLFunctionsTest:
- Assistant
Let me also check if there are any other places where ExpandStep is referenced to make sure I haven't missed any usages:
- Assistant
We're in the engine directory.
- Assistant
Good. ExpandStep is only used in SelectExecutionPlanner and the tests. The changes are minimal and correct.
Let me also look at the SQLExecutorAdditionalCoverageTest to make sure my changes don't break anything:
- Assistant
All tests pass. Let me now run a broader set of tests to make sure nothing is broken. Let me run all the SQL executor tests:
- Assistant
Let me try with a different pattern.
- Assistant
The one failure is
ScriptExecutionTest.commitRetryMultiThreadsSQLIncrementRepeatableRead:278which is unrelated to my changes - it's about bucket limits. Let me verify this test was already failing before my changes: - Assistant
Good, the failure is pre-existing - not caused by my changes. Let me restore my changes:
- Assistant
Now let me review all the changes I've made to make sure they are correct:
- Assistant
The changes look clean and correct. Let me now do a final verification:
- Assistant
All tests pass. Let me now submit my changes. Let me first do a final review of the diff:
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.
Identical first prompt
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- xiaomi/mimo-v2.5-proCompare side by side →
- gpt-5.6-solCompare side by side →
- gpt-5.6-solCompare side by side →
- gpt-5.6-solCompare side by side →