Squashed commit of the following:

lziq · lziq · commit 664a9f4e4224 · 2022-12-15T16:03:42.000-08:00
commit 895692e Author: R. C. Howell <RCHowell@users.noreply.github.com> Date: Thu Dec 15 13:32:52 2022 -0800 Prepares 0.9.1-SNAPSHOT (#934) commit 692d442 Author: R. C. Howell <RCHowell@users.noreply.github.com> Date: Thu Dec 15 11:09:39 2022 -0800 Prepares 0.9.0 release (#932) Co-authored-by: lziq <67429381+lziq@users.noreply.github.com> commit f7f41fb Author: R. C. Howell <RCHowell@users.noreply.github.com> Date: Thu Dec 15 11:09:14 2022 -0800 Revert "Marks GPML and WINDOW AST nodes as Experimental (#923)" (#933) This reverts commit f605f2b. commit f605f2b Author: R. C. Howell <RCHowell@users.noreply.github.com> Date: Wed Dec 14 15:30:47 2022 -0800 Marks GPML and WINDOW AST nodes as Experimental (#923) * Marks GPML and WINDOW AST nodes as Experimental * Marks window_expression as experimental commit 94f6435 Author: lziq <67429381+lziq@users.noreply.github.com> Date: Wed Dec 14 10:43:54 2022 -0800 Change `IonValue` & `ExprValue` conversion API (#931) commit 07b3845 Author: R. C. Howell <RCHowell@users.noreply.github.com> Date: Tue Dec 13 13:56:21 2022 -0800 Adds 0.9 migration guide (#930)
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -23,6 +23,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+### Changed
+
+### Deprecated
+
+### Fixed
+
+### Removed
+
+### Security
+
+## [0.9.0] - 2022-12-13
+
 ### Added
 - Adds simple auto-completion to the CLI.
 - Adds the IsListParenthesizedMeta meta to aid in differentiating between parenthesized and non-parenthesized lists
@@ -35,7 +49,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Adds continuous performance benchmarking to the CI for existing JMH benchmarks
   - Benchmark results can be seen on the project's GitHub Pages site
 - Adds the `pipeline` flag to the CLI to provide experimental usage of the PartiQLCompilerPipeline
-- Added `ExprValue.toIonValue(ion: IonSystem)` in kotlin, and `ExprValueKt.toIonValue(value: ExprValue, ion: IonSystem)` in Java to transform one `ExprValue` to a corresponding `IonValue`.
+- Added `ExprValue.toIonValue(ion: IonSystem)` in kotlin, and `ExprValueExtensionKt.toIonValue(value: ExprValue, ion: IonSystem)` in Java to transform one `ExprValue` to a corresponding `IonValue`.
+- Added `ExprValue.of(value: IonValue)` method to construct an `ExprValue` from an `IonValue`. 
 
 ### Changed
 - Now `CompileOption` uses `TypedOpParameter.HONOR_PARAMETERS` as default.
diff --git a/README.md b/README.md
@@ -31,7 +31,7 @@ This project is published to [Maven Central](https://search.maven.org/artifact/o
 
 | Group ID      | Artifact ID           | Recommended Version |
 |---------------|-----------------------|---------------------|
-| `org.partiql` | `partiql-lang-kotlin` | `0.8.2`             | 
+| `org.partiql` | `partiql-lang-kotlin` | `0.9.0`             | 
 
 
 For Maven builds, add the following to your `pom.xml`:
diff --git a/docs/upgrades/v0.8-to-v0.9-upgrade.md b/docs/upgrades/v0.8-to-v0.9-upgrade.md
@@ -0,0 +1,54 @@
+# v0.9.x
+
+## New features
+* Adds simple auto-completion to the CLI.
+* Adds the IsListParenthesizedMeta meta to aid in differentiating between parenthesized and non*parenthesized lists
+* Adds support for HAVING clause in planner
+* Adds support for collection aggregation functions in the EvaluatingCompiler and experimental planner
+* Adds support for the syntactic sugar of using aggregations functions in place of their collection aggregation function
+  counterparts (in the experimental planner)
+* Experimental implementation for window function `Lag` and `Lead`.
+* Adds support for EXPLAIN
+* Adds continuous performance benchmarking to the CI for existing JMH benchmarks
+    * Benchmark results can be seen on the project's GitHub Pages site
+* Adds the `pipeline` flag to the CLI to provide experimental usage of the PartiQLCompilerPipeline
+* Added `ExprValue.toIonValue(ion: IonSystem)` in kotlin, and `ExprValueKt.toIonValue(value: ExprValue, ion: IonSystem)` in Java to transform one `ExprValue` to a corresponding `IonValue`.
+
+## Deprecated items
+* Marks the GroupKeyReferencesVisitorTransform as deprecated. There is no functionally equivalent class.
+* Marks `ionValue` property in `ExprValue` interface as deprecated. The functional equivalent method is `ExprValue.toIonValue(ion: IonSystem)` in kotlin, and `ExprValueKt.toIonValue(value: ExprValue, ion: IonSystem)` in Java.
+* Marks `Lexer`, `Token`, `TokenType`, `SourcePosition`, and `SourceSpan` as deprecated. These will be removed without
+  any replacement.
+* Marks approximately 60 `ErrorCode`'s as deprecated. These will be removed without any replacement.
+* Marks `Property.TOKEN_TYPE` as deprecated. Please use `Property.TOKEN_DESCRIPTION`.
+
+## Misc/bug fixes
+* Fixes the ThreadInterruptedTests by modifying the time to interrupt parses. Also adds better exception exposure to
+  facilitate debugging.
+
+## Breaking changes
+
+### Breaking behavioral changes
+
+N/A
+
+### Breaking API changes
+* Removes the deprecated V0 AST in the codebase.
+* Removes the deprecated MetaContainer in the codebase, removed interfaces and classes include:
+    * [MetaContainer] Interface
+    * [MetaContainerImpl]
+    * [MetaDeserialize]
+    * [MemoizedMetaDeserializer]
+* Removes the deprecated Rewriter/AstWalker/AstVisitor in the code base, removed interfaces and classes include:
+    * [AstRewriter] Interface & [AstRewriterBase] class
+    * [AstVisitor] Interface & [AstVisitorBase] class
+    * [AstWalker] class
+    * [MetaStrippingRewriter] class
+* Removes the deprecated ExprNode and related files in the code base.
+    * [Parser] API `parseExprNode(source: String): ExprNode` has been removed.
+    * [CompilerPipeline] API `compile(query: ExprNode): Expression` has been removed.
+    * [ExprNode] and [AstNode] have been removed.
+    * Functions related to conversions between ExprNode and PartiqlAst have been removed.
+* Removes the deprecated SqlParser and SqlLexer
+* Removes the `CallAgg` node from the Logical, LogicalResolved, and Physical plans.
+* Removes the experimental `PlannerPipeline` and replaces it with `PartiQLCompilerPipeline`.
diff --git a/examples/src/main/java/org/partiql/examples/S3JavaExample.java b/examples/src/main/java/org/partiql/examples/S3JavaExample.java
@@ -31,7 +31,7 @@
 import org.partiql.lang.eval.Bindings;
 import org.partiql.lang.eval.EvaluationSession;
 import org.partiql.lang.eval.ExprValue;
-import org.partiql.lang.eval.ExprValueKt;
+import org.partiql.lang.eval.ExprValueExtensionsKt;
 import org.partiql.lang.eval.Expression;
 
 import java.io.IOException;
@@ -106,7 +106,7 @@ public void run() {
 
             // Uses ion-java to dump the result as JSON. It's possible to build your own writer and dump the ExprValue
             // as any format you want.
-            ExprValueKt.toIonValue(selectAndFilterResult, ion).writeTo(resultWriter);
+            ExprValueExtensionsKt.toIonValue(selectAndFilterResult, ion).writeTo(resultWriter);
             // result as JSON below
             // [{"name":"person_2"},{"name":"person_3","address":{"number":555,"street":"1st street","city":"Seattle"}}]
         } catch (IOException e) {
diff --git a/gradle.properties b/gradle.properties
@@ -1,5 +1,5 @@
 group=org.partiql
-version=0.8.2-SNAPSHOT
+version=0.9.1-SNAPSHOT
 
 ossrhUsername=EMPTY
 ossrhPassword=EMPTY
diff --git a/lang/src/main/kotlin/org/partiql/lang/eval/ExprValue.kt b/lang/src/main/kotlin/org/partiql/lang/eval/ExprValue.kt
@@ -25,11 +25,8 @@ import com.amazon.ion.IonSexp
 import com.amazon.ion.IonString
 import com.amazon.ion.IonStruct
 import com.amazon.ion.IonSymbol
-import com.amazon.ion.IonSystem
 import com.amazon.ion.IonTimestamp
-import com.amazon.ion.IonType
 import com.amazon.ion.IonValue
-import com.amazon.ion.Timestamp
 import com.amazon.ion.facet.Faceted
 import org.partiql.lang.eval.time.NANOS_PER_SECOND
 import org.partiql.lang.eval.time.Time
@@ -43,6 +40,15 @@ interface ExprValue : Iterable<ExprValue>, Faceted {
     /** The type of value independent of its implementation. */
     val type: ExprValueType
 
+    /**
+     * Materializes the expression value as an [IonValue].
+     *
+     * The returned value may or may not be tethered to a container, so it is
+     * the callers responsibility to deal with that accordingly (e.g. via `clone`).
+     */
+    @Deprecated("Please use [ExprValue.toIonValue()] to transform [ExprValue] to [IonValue]")
+    val ionValue: IonValue
+
     /** Returns the [Scalar] view of this value. */
     val scalar: Scalar
 
@@ -68,111 +74,60 @@ interface ExprValue : Iterable<ExprValue>, Faceted {
      * If this value has no children, then it should return the empty iterator.
      */
     override operator fun iterator(): Iterator<ExprValue>
-}
 
-/**
- * This method should only be used in case we want to get result from querying an Ion file or an [IonValue]
- */
-fun ExprValue.toIonValue(ion: IonSystem): IonValue =
-    when (type) {
-        ExprValueType.NULL -> ion.newNull(asFacet(IonType::class.java))
-        ExprValueType.MISSING -> ion.newNull().apply { addTypeAnnotation(MISSING_ANNOTATION) }
-        ExprValueType.BOOL -> ion.newBool(booleanValue())
-        ExprValueType.INT -> ion.newInt(longValue())
-        ExprValueType.FLOAT -> ion.newFloat(numberValue().toDouble())
-        ExprValueType.DECIMAL -> ion.newDecimal(bigDecimalValue())
-        ExprValueType.DATE -> {
-            val value = dateValue()
-            ion.newTimestamp(Timestamp.forDay(value.year, value.monthValue, value.dayOfMonth)).apply {
-                addTypeAnnotation(DATE_ANNOTATION)
+    companion object {
+        @JvmStatic
+        fun of(value: IonValue): ExprValue {
+            val valueFactory = ExprValueFactory.standard(value.system)
+            return when {
+                value.isNullValue && value.hasTypeAnnotation(MISSING_ANNOTATION) -> valueFactory.missingValue // MISSING
+                value.isNullValue -> NullExprValue(value.system, value.type) // NULL
+                value is IonBool -> valueFactory.newBoolean(value.booleanValue()) // BOOL
+                value is IonInt -> valueFactory.newInt(value.longValue()) // INT
+                value is IonFloat -> valueFactory.newFloat(value.doubleValue()) // FLOAT
+                value is IonDecimal -> valueFactory.newDecimal(value.decimalValue()) // DECIMAL
+                value is IonTimestamp && value.hasTypeAnnotation(DATE_ANNOTATION) -> {
+                    val timestampValue = value.timestampValue()
+                    valueFactory.newDate(timestampValue.year, timestampValue.month, timestampValue.day)
+                } // DATE
+                value is IonTimestamp -> valueFactory.newTimestamp(value.timestampValue()) // TIMESTAMP
+                value is IonStruct && value.hasTypeAnnotation(TIME_ANNOTATION) -> {
+                    val hourValue = (value["hour"] as IonInt).intValue()
+                    val minuteValue = (value["minute"] as IonInt).intValue()
+                    val secondInDecimal = (value["second"] as IonDecimal).decimalValue()
+                    val secondValue = secondInDecimal.toInt()
+                    val nanoValue = secondInDecimal.remainder(BigDecimal.ONE).multiply(NANOS_PER_SECOND.toBigDecimal()).toInt()
+                    val timeZoneHourValue = (value["timezone_hour"] as IonInt).intValue()
+                    val timeZoneMinuteValue = (value["timezone_minute"] as IonInt).intValue()
+                    valueFactory.newTime(Time.of(hourValue, minuteValue, secondValue, nanoValue, secondInDecimal.scale(), timeZoneHourValue * 60 + timeZoneMinuteValue))
+                } // TIME
+                value is IonSymbol -> valueFactory.newSymbol(value.stringValue()) // SYMBOL
+                value is IonString -> valueFactory.newString(value.stringValue()) // STRING
+                value is IonClob -> valueFactory.newClob(value.bytesValue()) // CLOB
+                value is IonBlob -> valueFactory.newBlob(value.bytesValue()) // BLOB
+                value is IonList && value.hasTypeAnnotation(BAG_ANNOTATION) -> valueFactory.newBag(value.map { of(it) }) // BAG
+                value is IonList -> valueFactory.newList(value.map { of(it) }) // LIST
+                value is IonSexp -> valueFactory.newSexp(value.map { of(it) }) // SEXP
+                value is IonStruct -> IonStructExprValue(valueFactory, value) // STRUCT
+                else -> error("Unrecognized IonValue to transform to ExprValue: $value")
             }
         }
-        ExprValueType.TIMESTAMP -> ion.newTimestamp(timestampValue())
-        ExprValueType.TIME -> timeValue().toIonValue(ion)
-        ExprValueType.SYMBOL -> ion.newSymbol(stringValue())
-        ExprValueType.STRING -> ion.newString(stringValue())
-        ExprValueType.CLOB -> ion.newClob(bytesValue())
-        ExprValueType.BLOB -> ion.newBlob(bytesValue())
-        ExprValueType.LIST -> mapTo(ion.newEmptyList()) {
-            if (it is StructExprValue)
-                it.toIonStruct(ion)
-            else
-                it.toIonValue(ion).clone()
-        }
-        ExprValueType.SEXP -> mapTo(ion.newEmptySexp()) {
-            if (it is StructExprValue)
-                it.toIonStruct(ion)
-            else
-                it.toIonValue(ion).clone()
-        }
-        ExprValueType.BAG -> mapTo(
-            ion.newEmptyList().apply { addTypeAnnotation(BAG_ANNOTATION) }
-        ) {
-            if (it is StructExprValue)
-                it.toIonStruct(ion)
-            else
-                it.toIonValue(ion).clone()
-        }
-        ExprValueType.STRUCT -> toIonStruct(ion)
     }
 
-private fun ExprValue.toIonStruct(ion: IonSystem): IonStruct {
-    return ion.newEmptyStruct().apply {
-        this@toIonStruct.forEach {
-            val nameVal = it.name
-            if (nameVal != null && nameVal.type.isText && it.type != ExprValueType.MISSING) {
-                val name = nameVal.stringValue()
-                add(name, it.toIonValue(ion).clone())
-            }
+    private class IonStructExprValue(
+        valueFactory: ExprValueFactory,
+        private val ionStruct: IonStruct
+    ) : StructExprValue(
+        valueFactory.ion,
+        StructOrdering.UNORDERED,
+        ionStruct.asSequence().map {
+            of(it).namedValue(valueFactory.newString(it.fieldName))
         }
-    }
-}
-
-fun IonValue.toExprValue(): ExprValue {
-    val valueFactory = ExprValueFactory.standard(system)
-    return when {
-        isNullValue && hasTypeAnnotation(MISSING_ANNOTATION) -> valueFactory.missingValue // MISSING
-        isNullValue -> NullExprValue(type) // NULL
-        this is IonBool -> valueFactory.newBoolean(booleanValue()) // BOOL
-        this is IonInt -> valueFactory.newInt(longValue()) // INT
-        this is IonFloat -> valueFactory.newFloat(doubleValue()) // FLOAT
-        this is IonDecimal -> valueFactory.newDecimal(decimalValue()) // DECIMAL
-        this is IonTimestamp && hasTypeAnnotation(DATE_ANNOTATION) -> {
-            val timestampValue = timestampValue()
-            valueFactory.newDate(timestampValue.year, timestampValue.month, timestampValue.day)
-        } // DATE
-        this is IonTimestamp -> valueFactory.newTimestamp(timestampValue()) // TIMESTAMP
-        this is IonStruct && hasTypeAnnotation(TIME_ANNOTATION) -> {
-            val hourValue = (this["hour"] as IonInt).intValue()
-            val minuteValue = (this["minute"] as IonInt).intValue()
-            val secondInDecimal = (this["second"] as IonDecimal).decimalValue()
-            val secondValue = secondInDecimal.toInt()
-            val nanoValue = secondInDecimal.remainder(BigDecimal.ONE).multiply(NANOS_PER_SECOND.toBigDecimal()).toInt()
-            val timeZoneHourValue = (this["timezone_hour"] as IonInt).intValue()
-            val timeZoneMinuteValue = (this["timezone_minute"] as IonInt).intValue()
-            valueFactory.newTime(Time.of(hourValue, minuteValue, secondValue, nanoValue, secondInDecimal.scale(), timeZoneHourValue * 60 + timeZoneMinuteValue))
-        } // TIME
-        this is IonSymbol -> valueFactory.newSymbol(stringValue()) // SYMBOL
-        this is IonString -> valueFactory.newString(stringValue()) // STRING
-        this is IonClob -> valueFactory.newClob(bytesValue()) // CLOB
-        this is IonBlob -> valueFactory.newBlob(bytesValue()) // BLOB
-        this is IonList && hasTypeAnnotation(BAG_ANNOTATION) -> valueFactory.newBag(map { it.toExprValue() }) // BAG
-        this is IonList -> valueFactory.newList(map { it.toExprValue() }) // LIST
-        this is IonSexp -> valueFactory.newSexp(map { it.toExprValue() }) // SEXP
-        this is IonStruct -> IonStructExprValue(valueFactory, this) // STRUCT
-        else -> error("Unrecognized IonValue to transform to ExprValue: $this")
-    }
-}
+    ) {
+        override val bindings: Bindings<ExprValue> =
+            IonStructBindings(valueFactory, ionStruct)
 
-private class IonStructExprValue(
-    valueFactory: ExprValueFactory,
-    private val ionStruct: IonStruct
-) : StructExprValue(
-    StructOrdering.UNORDERED,
-    ionStruct.asSequence().map {
-        it.toExprValue().namedValue(valueFactory.newString(it.fieldName))
+        override val ionValue: IonValue
+            get() = ionStruct
     }
-) {
-    override val bindings: Bindings<ExprValue> =
-        IonStructBindings(valueFactory, ionStruct)
 }
diff --git a/lang/src/main/kotlin/org/partiql/lang/eval/ExprValueExtensions.kt b/lang/src/main/kotlin/org/partiql/lang/eval/ExprValueExtensions.kt
@@ -16,6 +16,10 @@ package org.partiql.lang.eval
 
 import com.amazon.ion.IntegerSize
 import com.amazon.ion.IonInt
+import com.amazon.ion.IonStruct
+import com.amazon.ion.IonSystem
+import com.amazon.ion.IonType
+import com.amazon.ion.IonValue
 import com.amazon.ion.Timestamp
 import org.partiql.lang.ast.SourceLocationMeta
 import org.partiql.lang.errors.ErrorCode
@@ -720,3 +724,61 @@ fun Sequence<ExprValue>.multiplicities(): TreeMap<ExprValue, Int> {
     }
     return multiplicities
 }
+
+/**
+ * This method should only be used in case we want to get result from querying an Ion file or an [IonValue]
+ */
+fun ExprValue.toIonValue(ion: IonSystem): IonValue =
+    when (type) {
+        ExprValueType.NULL -> ion.newNull(asFacet(IonType::class.java))
+        ExprValueType.MISSING -> ion.newNull().apply { addTypeAnnotation(MISSING_ANNOTATION) }
+        ExprValueType.BOOL -> ion.newBool(booleanValue())
+        ExprValueType.INT -> ion.newInt(longValue())
+        ExprValueType.FLOAT -> ion.newFloat(numberValue().toDouble())
+        ExprValueType.DECIMAL -> ion.newDecimal(bigDecimalValue())
+        ExprValueType.DATE -> {
+            val value = dateValue()
+            ion.newTimestamp(Timestamp.forDay(value.year, value.monthValue, value.dayOfMonth)).apply {
+                addTypeAnnotation(DATE_ANNOTATION)
+            }
+        }
+        ExprValueType.TIMESTAMP -> ion.newTimestamp(timestampValue())
+        ExprValueType.TIME -> timeValue().toIonValue(ion)
+        ExprValueType.SYMBOL -> ion.newSymbol(stringValue())
+        ExprValueType.STRING -> ion.newString(stringValue())
+        ExprValueType.CLOB -> ion.newClob(bytesValue())
+        ExprValueType.BLOB -> ion.newBlob(bytesValue())
+        ExprValueType.LIST -> mapTo(ion.newEmptyList()) {
+            if (it is StructExprValue)
+                it.toIonStruct(ion)
+            else
+                it.toIonValue(ion).clone()
+        }
+        ExprValueType.SEXP -> mapTo(ion.newEmptySexp()) {
+            if (it is StructExprValue)
+                it.toIonStruct(ion)
+            else
+                it.toIonValue(ion).clone()
+        }
+        ExprValueType.BAG -> mapTo(
+            ion.newEmptyList().apply { addTypeAnnotation(BAG_ANNOTATION) }
+        ) {
+            if (it is StructExprValue)
+                it.toIonStruct(ion)
+            else
+                it.toIonValue(ion).clone()
+        }
+        ExprValueType.STRUCT -> toIonStruct(ion)
+    }
+
+private fun ExprValue.toIonStruct(ion: IonSystem): IonStruct {
+    return ion.newEmptyStruct().apply {
+        this@toIonStruct.forEach {
+            val nameVal = it.name
+            if (nameVal != null && nameVal.type.isText && it.type != ExprValueType.MISSING) {
+                val name = nameVal.stringValue()
+                add(name, it.toIonValue(ion).clone())
+            }
+        }
+    }
+}
diff --git a/lang/src/main/kotlin/org/partiql/lang/eval/ExprValueFactory.kt b/lang/src/main/kotlin/org/partiql/lang/eval/ExprValueFactory.kt
@@ -234,7 +234,7 @@ private class ExprValueFactoryImpl(override val ion: IonSystem) : ExprValueFacto
         BlobExprValue(value)
 
     override fun newFromIonValue(value: IonValue): ExprValue =
-        value.toExprValue()
+        ExprValue.of(value)
 
     override fun newFromIonReader(reader: IonReader): ExprValue =
         newFromIonValue(ion.newValue(reader))
diff --git a/lang/src/main/kotlin/org/partiql/lang/eval/IonStructBindings.kt b/lang/src/main/kotlin/org/partiql/lang/eval/IonStructBindings.kt
@@ -67,6 +67,6 @@ internal class IonStructBindings(private val valueFactory: ExprValueFactory, pri
             BindingCase.SENSITIVE -> caseSensitiveLookup(bindingName.name)
             BindingCase.INSENSITIVE -> caseInsensitiveLookup(bindingName.name)
         }?.let {
-            it.toExprValue().namedValue(valueFactory.newString(it.fieldName))
+            ExprValue.of(it).namedValue(valueFactory.newString(it.fieldName))
         }
 }
diff --git a/lang/src/test/kotlin/org/partiql/lang/eval/EvaluatingCompilerSelectStarTests.kt b/lang/src/test/kotlin/org/partiql/lang/eval/EvaluatingCompilerSelectStarTests.kt
diff --git a/test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/TestRunner.kt b/test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/TestRunner.kt

Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,6 @@ internal class IonStructBindings(private val valueFactory: ExprValueFactory, pri`
`67`	`67`	`BindingCase.SENSITIVE -> caseSensitiveLookup(bindingName.name)`
`68`	`68`	`BindingCase.INSENSITIVE -> caseInsensitiveLookup(bindingName.name)`
`69`	`69`	`}?.let {`
`70`		`- it.toExprValue().namedValue(valueFactory.newString(it.fieldName))`
	`70`	`+ ExprValue.of(it).namedValue(valueFactory.newString(it.fieldName))`
`71`	`71`	`}`
`72`	`72`	`}`