MongoSQL 오류

설명: 함수(예: 사인, 절대, 반올림)의 인수 수가 잘못되었습니다.

일반적인 원인: 함수에 추가 인수가 있거나 누락된 인수가 있습니다. 예를 들어 a 가 int 인 SELECT ROUND(a,1,5) FROM foo 에서 라운드에 추가 인수가 있습니다.

해결 단계: 오류 메시지는 잘못된 수의 인수를 가진 함수와 포함해야 하는 인수의 개수를 나타냅니다. 이 정보를 사용하여 쿼리를 수정합니다. 수정된 예시 쿼리: SELECT ROUND(a,1) FROM foo.

설명: 지정된 연산(예: Sub, And, Substring)에 잘못된 유형(예: string, int)의 인수가 있습니다.

일반적인 원인: 지정된 함수에 잘못된 유형의 필드가 잘못 사용되었습니다. 예를 들어 str 이 문자열 유형인 SELECT ROUND(str,5) FROM foo 은 이 오류를 발생시킵니다.

해결 단계: 오류 메시지는 잘못된 유형의 인수를 가진 함수와 예상되는 유형을 나타냅니다. 이 정보를 사용하여 쿼리를 수정합니다. 예시 쿼리 수정: SELECT ROUND(a,5) FROM foo 여기서 a 은 int 입니다.

설명: 애그리게이션에 제공된 인수가 자체적으로 비교 가능한 유형이 아닙니다.

일반적인 원인: 집계하려는 열의 유형이 object 또는 array 이며, 서로 비교 불가입니다.

예를 들어 obj 이 object 인 SELECT * FROM myCol GROUP BY a AGGREGATE MIN(obj) as min 은 이 오류를 발생시킵니다.

해결 단계: 적절한 유형의 열에만 AGGREGATE 함수를 사용합니다. array 또는 object 내의 값에 대해 AGGREGATE 하려면 UNwind 또는 FLATTEN 데이터 소스 키워드를 사용하세요. 예시 쿼리 수정: SELECT * FROM myCol GROUP BY a AGGREGATE MIN(a) as min 여기서 a 은 int 입니다.

설명: COUNT(DISTINCT *) 은(는) 지원되지 않습니다.

일반적인 원인: COUNT(DISTINCT *) ( SELECT COUNT(DISTINCT *) FROM foo )의 사용은 지원되지 않습니다.

해결 단계: 쿼리에서 COUNT(DISTINCT *) 사용을 모두 제거합니다.

설명: 피연산자의 비교 불가 유형(예: int를 문자열과 비교) 때문에 지정된 비교 작업(예: Lte, 비트윈)을 실행할 수 없습니다.

일반적인 원인: 지정된 비교 작업에 서로 다른 두 가지 유형의 필드가 사용되었습니다. 예를 들어 SELECT * FROM foo WHERE a <= b 에서 a 은 int 이고 b 은 string 입니다. 또한 objects 및 arrays 는 비교 가능한 유형이 아니므로 비교 작업에 사용할 수 없습니다.

해결 단계: 오류 메시지는 충돌하는 유형이 있는 비교 작업을 나타냅니다. 이 정보를 사용하여 쿼리를 수정합니다. 예시 쿼리 수정: SELECT * FROM foo WHERE a1 <= a2 여기서 a1 및 a2 는 모두 int 유형입니다.

설명: 필드를 찾을 수 없고(존재하지 않을 가능성이 높기 때문에) 액세스할 수 없습니다.

일반적인 원인: 존재하지 않는 필드에 액세스하려고 합니다. 예를 들어 f 이 존재하지 않는 필드인 SELECT foo.f FROM foo 로 인해 이 오류가 발생합니다.

해결 단계: 가능한 경우 오류 메시지는 의도한 입력이었을 수 있는 유사한 필드 이름을 제안합니다. 그러나 유사한 항목이 발견되지 않으면 MongoSQL은 필드 이름 제안을 제공하지 않습니다. 이 정보를 사용하여 쿼리를 수정합니다. 예시 쿼리 수정: a 이 foo 의 a 필드로 존재하는 SELECT foo.a FROM foo

설명: 스칼라 하위 쿼리 결과 집합의 카디널리티가 1보다 클 수 있습니다. 결과 집합의 카디널리티는 0 또는 1이어야 합니다.

일반적인 원인: 스칼라 하위 쿼리가 두 개 이상의 문서(또는 SQL의 행)를 반환할 수 있습니다. 예를 들어 SELECT (SELECT a FROM foo) FROM bar 은 이 오류를 유발하는데, 그 이유는 (SELECT a FROM foo) 가 2개 이상의 문서(또는 행)를 반환할 수 있기 때문입니다.

해결 단계: 하위 쿼리에 LIMIT 1 를 추가하여 1개 문서/행만 반환되도록 합니다. 올바른 예시 쿼리: SELECT (SELECT a FROM foo LIMIT 1) FROM bar.

설명: 지정된 키는 자체적으로 비교할 수 없는 유형이므로 이를 기준으로 정렬할 수 없습니다.

일반적인 원인: 정렬하려는 열이 object 또는 array 유형 중 하나이며, 이는 자체적으로 비교 가능한 유형이 아닙니다. 예를 들어 obj 이 object 인 SELECT * FROM foo ORDER BY obj 에서 이 오류가 발생합니다.

해결 단계: 적절한 유형의 열만 정렬합니다. array 또는 object 내의 값을 정렬하려면 UNwind 또는 FLATTEN 데이터 소스 키워드를 사용하세요. 예시 쿼리 수정: SELECT * FROM foo ORDER BY a 여기서 a 은 int 입니다.

설명: 지정된 키는 자신과 비교할 수 없는 유형이므로 지정된 키로 그룹화할 수 없습니다.

일반적인 원인: 그룹화하려는 열의 유형이 object 또는 array 이며, 이는 서로 비교할 수 있는 유형이 아닙니다. 예를 들어 obj 이 object 인 SELECT * FROM foo GROUP BY obj 에서 이 오류가 발생합니다.

해결 단계: 적절한 유형의 열만 그룹화합니다. array 또는 object 내의 값을 기준으로 그룹화하려면 UNwind 또는 FLATTEN 데이터 소스 키워드를 사용하세요. 예시 쿼리 수정: SELECT * FROM foo ORDER BY a 여기서 a 은 int 입니다.

설명: UNwind INDEX 이름이 기존 필드 이름과 충돌합니다.

일반적인 원인: INDEX 이름이 기존 필드 이름과 동일합니다. 예를 들어 foo 컬렉션에 b 필드가 있는 경우 SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b) 쿼리에서 이 오류가 발생합니다.

해결 단계: INDEX 이름을 기존 필드가 아닌 이름으로 변경합니다. 예시 쿼리 수정: SELECT * FROM UNWIND(foo WITH PATH => a, INDEX => b2) 여기서 b2 은 기존 필드 이름이 아닙니다.

설명: 지정된 데이터베이스에서 collection을 찾을 수 없습니다.

일반적인 원인: 잘못된 데이터베이스를 보고 있거나 collection을 찾을 수 없는 원인이 되는 오타를 만들었을 수 있습니다. 예를 들어, collection baz 이 존재하지 않는 경우, 쿼리 SELECT * FROM baz 를 수행하면 이 오류가 발생합니다.

해결 단계: 모든 내용의 철자가 올바른지, 올바른 데이터베이스를 보고 있는지 확인합니다. 예시 쿼리 수정: SELECT * FROM foo 여기서 foo 은(는) 현재 데이터베이스에 존재합니다.

설명: 비교 작업에서 확장 JSON이 감지되었습니다. MongoSQL은 확장 JSON과의 직접 비교를 지원하지 않습니다. 대신 캐스팅을 사용합니다(예: '해결 단계' 참조).

일반적인 원인: 쿼리에 확장 JSON을 사용하고 올바른 데이터 유형으로 암시적으로 캐스팅할 것으로 예상합니다. 예를 들어, 확장 JSON 문자열이 암시적으로 ObjectID 로 캐스팅된다고 생각하여 누군가가 select _id from customers where _id = '{"$oid":"5ca4bbcea2dd94ee58162a6a"}' 쿼리를 작성할 수 있습니다. 그러나 이는 그렇지 않습니다.

해결 단계: 확장 JSON 형식을 사용하지 말고 항상 명시적으로 CAST하세요. 오류 메시지는 수행해야 할 작업(캐스트)을 권장합니다. 수정된 예시 쿼리: select _id from customers where _id = CAST('5ca4bbcea2dd94ee58162a6a' as ObjectID). 이 쿼리는 명시적으로 ObjectID 로 캐스팅합니다.

설명: 필드에 지원되지 않는 BSON 유형이 있습니다.

일반적인 원인: 필드에 MongoSQL에서 지원하지 않는 BSON 유형이 있습니다. 예를 들어 foo 컬렉션에 undefined 유형의 b 필드가 있는 경우 SELECT * FROM foo 쿼리로 인해 이 오류가 발생합니다.

해결 단계: BSON type을 MongoSQL에서 지원하는 것으로 변경합니다. 오류 메시지는 어떤 BSON types가 지원 되는지 제안합니다. . 수정된 예시 쿼리: SELECT * FROM foo 여기서 foo 은(는) 현재 데이터베이스에 존재하고 b 은(는) undefined 유형이 아닙니다.

설명: 바이너리 데이터 유형의 필드에 지원되지 않는 하위 유형인 uuid old가 있습니다.

일반적인 원인: 역사적으로 서로 다른 드라이버가 서로 다른 바이트 순서를 사용하여 Uuid를 작성해왔습니다. 이는 현재 지원되지 않는 uuid 유형을 사용하여 드라이버가 작성한 이전 데이터의 경우 발생할 수 있습니다.

해결 단계: 이 데이터 쿼리는 Atlas SQL에서 지원되지 않습니다.

설명: 이 오류는 인식할 수 없는 토큰을 제외한 모든 파서 오류에 공통적으로 발생합니다.

일반적인 원인: 이 오류는 포괄적 오류이므로 여러 가지 다양한 MEAN를 가질 수 있습니다. 그러나 이는 일반적으로 일부 토큰(키워드)이 잘못 사용되었음을 의미합니다.

해결 단계: 이 오류는 여러 가지 메시지를 전달할 수 있으므로 해당 메시지에 주의를 기울이는 것이 중요합니다. 또한 입력 쿼리를 살펴보고 모든 절(SQL 문 전체)이 지침에 지정된 대로 작성되었는지 확인하는 것이 좋습니다.

설명: 예기치 않거나 인식할 수 없는 토큰이 발견되었습니다.

일반적인 원인: 철자가 잘못되었거나 순서/형식이 잘못되었을 수 있습니다. 예를 들어 SELECT ** FROM foo AS f 은 ** 유형으로 인해 이 오류를 발생시킵니다.

해결 단계: 모든 항목의 철자가 올바른지, 올바른 순서/형식으로 입력되었는지 확인합니다. 또한 이 오류는 넣으려고 MEAN 토큰 목록을 제안합니다. 수정된 예시 쿼리: SELECT * FROM foo AS f.

설명: 값이 여러 개인 SELECT 목록에는 네임스페이스가 아닌 * 가 포함될 수 없습니다(즉, SELECT a, *, b FROM myTable 은 지원되지 않음). 네임스페이스가 아닌 * 는 단독으로 사용해야 합니다.

일반적인 원인: 이 쿼리에 표시된 대로 동일한 쿼리에서 * 및 기타 항목을 선택합니다: SELECT *, a from foo.

해결 단계: * 만 선택하거나(즉, SELECT * FROM ... ), * 를 포함하지 않고 여러 값을 선택합니다(즉, SELECT a, b FROM ... ).

설명: 배열 데이터 소스에 참고가 포함되어 있습니다. 배열 데이터 소스는 상수여야 합니다.

일반적인 원인: SELECT * FROM [{'a': foo.a}] AS arr 쿼리로 표시된 배열 데이터 소스의 필드에 액세스합니다.

해결 단계: 상수만 포함하도록 배열 데이터 소스를 수정합니다. 수정된 예시 쿼리: SELECT * FROM [{'a': 34}] AS arr.

설명: SELECT DISTINCT는 허용되지 않습니다.

일반적인 원인: SELECT DISTINCT 이 쿼리에 사용되었습니다. 예를 들어 SELECT DISTINCT * from foo 쿼리는 이 오류를 발생시킵니다.

해결 단계: 쿼리에 SELECT DISTINCT 을(를) 사용하지 마세요.

설명: 고유 유니온(Union)은 허용되지 않습니다. UNION ALL 만 수행할 수 있습니다(즉, 중복 값이 항상 허용되어야 함).

일반적인 원인: UNION ALL UNION 을(를) 사용합니다. 예를 들어 SELECT a FROM foo AS foo UNION SELECT b, c FROM bar AS bar 쿼리는 이 오류를 발생시킵니다.

해결 단계: 유니온을 수행할 때만 UNION ALL 를 사용합니다. 수정된 예시 쿼리: SELECT a FROM foo AS foo UNION ALL SELECT b, c FROM bar AS bar .

설명: SELECT 목록에서 참고된 데이터 소스를 찾을 수 없습니다.

일반적인 원인: <field> 에 하위 필드가 없는 SELECT <field>.* FROM ... 과 같은 작업을 수행하는 경우. 예를 들어 a 이 int 인 SELECT a.* FROM foo 쿼리는 이 오류를 발생시킵니다.

해결 단계: 존재하지 않는 필드에 액세스하려는 모든 필드 액세스를 제거합니다.

설명: 데이터 소스에서 필드를 찾을 수 없습니다.

일반적인 원인: 필드의 철자가 잘못되었거나 존재하지 않거나 잘못된 collection을 찾고 있습니다. 예를 들어, foo collection에 aa 이 존재하지 않으면 Select aa from foo 로 인해 이 오류가 발생합니다.

해결 단계: 필드의 철자가 올바른지, 올바른 컬렉션을 찾고 있는지 확인합니다. 또한 오류 메시지는 MEAN 수 있는 유사한 필드를 제안합니다.

설명: 필드가 여러 데이터 소스에 존재하며 모호합니다.

일반적인 원인: collection(또는 다른 데이터 소스)에 동일한 이름의 필드가 두 개 이상 있습니다. 예를 들어 a 가 의 foo 필드라고SELECT a FROM foo AS coll JOIN foo AS coll2 가정하면 collection 및 collection coll coll2 모두 필드가 있어 이 모호해지기 때문에 로 인해 이 a 오류가 a 발생합니다.

해결 단계: 참고를 한정합니다( <Collection>.<field> field ). 위의 예에서 coll.a 또는 coll2.a 을(를) 사용하면 이 오류가 해결됩니다.

설명: * 인수는 COUNT 애그리게이션 함수에서만 유효합니다.

일반적인 원인: COUNT는 * 인수, 즉 COUNT(*) 을 지원하는 유일한 애그리게이션 작업입니다. * 인수를 다른 작업(예: SUM(*) )에 전달하면 이 오류가 발생합니다. 예를 들어 쿼리 SELECT * FROM foo AS arr GROUP BY a AS a AGGREGATE SUM(*) AS gsum 입니다.

해결 단계: COUNT 에 대한 인수로 * 만 사용합니다.

설명: 애그리게이션 함수가 스칼라 위치에서 사용되었습니다.

일반적인 원인: 스칼라 함수만 사용할 수 있는 애그리게이션 함수 사용. 예를 들어 SELECT VALUE {'suma': SUM(a)} FROM db.bar AS bar GROUP BY a AS a 쿼리는 SUM(a) 이 애그리게이션 함수이기 때문에 이 오류를 발생시킵니다.

해결 단계: 스칼라 함수만 가질 수 있는 곳에서 애그리게이션 함수를 제거합니다.

설명: 애그리게이션 위치에서 스칼라 함수가 사용되었습니다.

일반적인 원인: 애그리게이션 함수만 사용할 수 있는 스칼라 함수 사용. 예를 들어 SELECT * FROM foo GROUP BY a AGGREGATE round(a) AS round 쿼리는 round 이 스칼라 함수이기 때문에 이 오류를 발생시킵니다.

해결 단계: 애그리게이션 함수만 사용할 수 있는 위치에서 스칼라 함수를 제거합니다.

설명: GROUP BY 애그리게이션 함수 목록에서 비애그리게이션 표현식이 발견되었습니다.

일반적인 원인: 애그리게이션이 있어야 할 곳에 애그리게이션 또는 스칼라 함수 이외의 것을 배치하는 경우. (애그리게이션 대신 스칼라 함수를 사용하면 다른 오류가 발생합니다: 오류 3012). 예를 들어 SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) + 7 AS whatever 쿼리는 애그리게이션 대신 애그리게이션과 함께 추가 연산이 있기 때문에 이러한 오류가 발생합니다.

해결 단계: 애그리게이션이 허용되는 곳에서만 애그리게이션을 사용하세요. 수정된 예시 쿼리: SELECT * FROM foo GROUP BY a AGGREGATE COUNT(*) AS whatever.

설명: 애그리게이션 함수에는 정확히 하나의 인수가 있어야 합니다.

일반적인 원인: 애그리게이션 함수에 인수가 두 개 이상 있습니다. 예를 들어 SELECT * FROM foo GROUP BY a AGGREGATE min(a,b) AS min 쿼리는 min 애그리게이션을 위해 두 개의 인수를 제공하기 때문에 이 오류가 발생합니다.

해결 단계: 애그리게이션에 인수가 하나만 있는지 확인합니다. 추가 인수를 모두 제거합니다. 수정된 예시 쿼리: SELECT * FROM foo GROUP BY a AGGREGATE min(b) AS min.

설명: 스칼라 함수는 DISTINCT를 지원하지 않습니다.

일반적인 원인: 스칼라 함수에서 DISTINCT 사용. 예를 들어 SELECT ROUND(DISTINCT a,2) FROM foo 쿼리는 이 오류를 발생시킵니다.

해결 단계: 스칼라 함수에는 DISTINCT 을(를) 사용하지 마세요. DISTINCT 는 애그리게이션 함수에서만 사용해야 합니다. 수정된 예시 쿼리: SELECT ROUND(a,2) FROM foo.

설명: 파생 데이터 소스에 겹치는 필드가 있습니다.

일반적인 원인: 지정된 하위 쿼리 내에 동일한 이름의 필드가 각각 있는 여러 데이터 소스를 포함하면 이 오류가 발생합니다. 예를 들어 bar 컬렉션과 foo 컬렉션에 동일한 이름의 필드가 있다고 가정하면 SELECT * FROM (SELECT * FROM foo AS foo, bar AS bar) AS derived 쿼리가 이 오류를 발생시킵니다.

해결 단계: 공통 필드 이름을 업데이트하여 데이터 소스 간에 고유하게 만듭니다. 이를 수행하는 간단한 방법은 같은 이름을 가진 필드에 고유한 이름의 별칭을 지정하는 것입니다. 다음은 이 기술을 사용하여 수정된 쿼리 예시입니다: SELECT * FROM (SELECT a, b, c, ..., z, FROM foo, a AS bar_a, b AS bar_b, c AS bar_c, ..., z AS bar_z FROM bar) AS derived.

설명: OUTER JOIN에 JOIN 조건이 누락되었습니다. OUTER JOIN은 JOIN 조건을 지정해야 합니다.

일반적인 원인: OUTER JOIN에 JOIN 조건이 누락되었습니다. 예를 들어 SELECT * FROM foo AS foo LEFT OUTER JOIN bar 쿼리는 쿼리의 필수 ON <condition> 부분이 누락되었기 때문에 이 오류를 발생시킵니다.

해결 단계: JOIN 조건(예: ON <condition> )을 추가합니다. 수정된 예시 쿼리: SELECT * FROM foo AS foo LEFT OUTER JOIN bar ON a = a .

설명: 중복 필드로 인해 스키마 환경을 생성할 수 없습니다.

일반적인 원인: 여러 collection에 동일한 별칭이 있습니다. 예를 들어 SELECT * FROM foo AS alias, bar AS alias 쿼리는 이 오류를 발생시킵니다.

해결 단계: 별칭이 collection에 대해 고유한지 확인합니다. 수정된 예시 쿼리: SELECT * from foo as foo_alias, bar as bar_alias.

설명: 스칼라 하위 쿼리 표현식의 차수는 1이어야 합니다.

일반적인 원인: 스칼라 하위 쿼리 표현식에서 둘 이상의 필드(또는 SQL의 열)를 선택합니다. 예를 들어 SELECT (SELECT * FROM foo LIMIT 1) FROM bar AS bar 쿼리는 하위 쿼리가 SELECT * 를 실행 중이므로 여러 필드를 선택하기 때문에 이러한 오류가 발생합니다.

해결 단계: 단일 필드만 선택하도록 하위 쿼리를 수정합니다. 수정된 예시 쿼리: SELECT (SELECT a FROM foo LIMIT 1) FROM bar AS bar

설명: 문서에 동일한 이름의 필드가 여러 개 있습니다.

일반적인 원인: collection에서 여러 필드를 선택하고 다음 쿼리에 표시된 것과 동일한 별칭을 지정합니다: SELECT a AS alias, b AS alias FROM foo.

해결 단계: 필드의 중복된 별칭을 고유한 이름으로 변경합니다. 수정된 예시 쿼리: SELECT a as a_alias, b as b_alias FROM foo.

설명: 동일한 FLATTEN 옵션이 두 번 이상 정의되었습니다.

일반적인 원인: 다음 쿼리에서 볼 수 있듯이 동일한 옵션이 두 번 이상 정의되었습니다: SELECT * FROM FLATTEN(foo WITH depth => 1, depth => 2).

해결 단계: 중복된 옵션을 모두 제거하여 각 옵션이 한 번만 사용되도록 합니다. 수정된 예시 쿼리: SELECT * FROM FLATTEN(foo WITH depth => 1).

설명: 스키마 정보가 데이터 소스 병합을 허용하기에 충분하지 않습니다.

일반적인 원인: 스키마 정보가 충분하지 않은 collection을 평면화하려고 시도합니다. 예를 들어 스키마가 정의되지 않은 collection noSchemaInfo 이 있다고 가정할 때 쿼리 SELECT * FROM FLATTEN(noSchemaInfo) 를 실행하면 이 오류가 발생합니다. 또 다른 일반적인 원인은 additional_properties 가 true 로 설정된 스키마 또는 스키마의 일부 필드를 사용하여 collection을 평면화하려고 하는 것입니다.

해결 단계: 스키마의 모든 필드를 정의하여 스키마가 충분히 정의되었는지 확인합니다. 또한 additional_properties 을 true 로 설정하지 않도록 합니다. 대신 스키마를 완전히 정의합니다.

설명: 스키마 내의 필드는 다형성 Realm 객체 유형이므로(즉, document 또는 int 일 수 있는 필드를 고려) 평면화할 수 없습니다. null 및 missing 객체 다형성이 허용됩니다. 병합은 객체(일명 문서) 유형에서만 작동하므로 일부 필드가 문서가 아닐 가능성이 있는 경우(다른 가능성이 null 또는 missing 인 경우 제외), 병합할 수 없습니다.

일반적인 원인: Realm 객체 유형인 필드를 포함하는 스키마가 있는 collection을 병합하려고 합니다. 예를 들어, collection이라는 이름의 coll 에 Realm 객체 유형인 필드가 있다고 가정하면, SELECT * FROM FLATTEN(coll) 쿼리를 실행하면 이 오류가 발생합니다.

해결 단계: 객체 유형만 병합할 수 있습니다. 필드가 평면화될 수 있도록 하려면 해당 필드의 스키마가 객체 유형이어야 합니다. 이 규칙의 유일한 예외는 null이거나 누락된 객체입니다. 다형성임에도 불구하고 이러한 객체를 평면화할 수 있습니다. 이 오류를 수정하려면 다형성 객체 유형의 필드가 있는 컬렉션을 평면화하려는 시도를 중지하거나 해당 필드의 스키마를 객체 유형 전용으로 변경해야 합니다.

설명: 동일한 UNwind 옵션이 두 번 이상 정의되었습니다.

일반적인 원인: 다음 쿼리에서 볼 수 있듯이 동일한 옵션이 두 번 이상 사용되었습니다: SELECT * FROM UNWIND(foo WITH PATH => a, PATH => b).

해결 단계: 중복된 옵션을 모두 제거하여 각 옵션이 한 번만 사용되도록 합니다. 수정된 예시 쿼리: SELECT * FROM UNWIND(foo WITH PATH => a).

설명: UNwind에 PATH 옵션이 누락되었습니다. UNwind는 PATH 옵션을 지정해야 합니다.

일반적인 원인: 다음 쿼리 SELECT * FROM UNWIND(foo) 에 표시된 대로 UNwind에 PATH 옵션이 누락되었습니다.

해결 단계: UNwind에 PATH 옵션을 추가합니다. 수정된 예시 쿼리: SELECT * FROM UNWIND(foo WITH PATH => a).

설명: UNWind PATH 옵션은 식별자가 아닙니다. 그러나 하나여야 합니다.

일반적인 원인: UNWind PATH 옵션은 다음 쿼리 SELECT * FROM UNWIND(foo WITH PATH => {'a': []}.a) 에 표시되는 식별자가 아닙니다.

해결 단계: UNwind PATH 옵션을 식별자로 변경합니다. 수정된 예시 쿼리: SELECT * FROM UNWIND(foo WITH PATH => a).

설명: CAST의 대상 유형이 유효하지 않은 유형입니다(예: 알 수 없는 유형이거나 MongoSQL이 캐스팅을 지원하지 않는 유형).

일반적인 원인: MongoSQL이 캐스팅을 지원하지 않는 유형으로 캐스팅. 예를 들어 SELECT CAST(a AS DATE) FROM foo쿼리는

이 오류가 발생하는 이유는 DATE 가 지원되는 대상 유형이 아니기 때문입니다.

해결 단계: 지원되는 대상 유형에만 캐스팅합니다. 유효한 대상 유형은 ARRAY, 문서, DOUBLE, STRING, ObjectId, BOOL, BSON, INT, Long, DECIMAL 또는 해당 SQL 유형 별칭 REAL, FLOAT, varCHAR, CHAR, CHARACTER, CHAR VARYING, CHARACTER입니다. VARYING, DEC, NUMERIC, BIT, BOOLEAN, TIME스탬프, INTEGER,SMALLINT. 수정된 예시 쿼리: SELECT CAST(a AS BSON_DATE) FROM foo.

설명: 정렬 키는 복잡한 표현식을 사용하므로 유효하지 않습니다(예: ORDER BY {'a': b}.a 은 유효하지 않음).

일반적인 원인: 복잡한 표현식 또는 '불순한' 필드 경로를 ORDER BY하려고 시도합니다. 예를 들어, SELECT * FROM foo ORDER BY CAST(d AS DOCUMENT).a쿼리는

이 오류가 발생하는 이유는 CAST(d AS DOCUMENT) 이 복잡한 표현식이기 때문입니다.

해결 단계: '순수' 필드 경로로만 정렬합니다. "순수" 필드 경로는 다음으로 구성됩니다.

식별자(예: foo.d.a 또는 a)

설명: 필드 이름 충돌로 인해 네임스페이스가 아닌 결과 집합을 반환할 수 없습니다.

일반적인 원인: $sql 애그리게이션 excludeNamespaces 필드를 true (으)로 설정하고 동일한 필드 이름으로 여러 collection을 쿼리하면 이 오류가 발생합니다. 이 옵션은 컬렉션 네임스페이스를 제거하므로 다른 컬렉션에 속한 동일한 이름의 필드는 더 이상 고유하지 않습니다. 예를 들어 각각 필드 a 와 SELECT foo.*, bar.a FROM foo, bar 과 같은 쿼리가 있는 collection foo 및 bar 를 생각해 보겠습니다. 결과 세트에 collection 네임스페이스가 있으면 두 개의 a 필드를 foo 과 bar 로 구분할 수 있습니다. 그러나 collection 네임스페이스가 없으면 서로 구분할 수 없습니다.

해결 단계: 이 오류를 수정하는 가장 좋은 방법은 별칭을 사용하여 충돌하는 필드를 고유하게 만드는 것입니다. 수정된 예시 쿼리: SELECT foo.*, bar.a AS a_unique_alias from foo, bar.