/*
 * This file was auto-generated by speedy-antlr-tool v1.3.2
 *  https://github.com/amykyta3/speedy-antlr-tool
 */

#include "sa_fugue_sql_translator.h"


SA_fugue_sqlTranslator::SA_fugue_sqlTranslator(speedy_antlr::Translator *translator) {
    this->translator = translator;
}

SA_fugue_sqlTranslator::~SA_fugue_sqlTranslator() {
    Py_XDECREF(FugueLanguageContext_cls);
    Py_XDECREF(FugueSingleStatementContext_cls);
    Py_XDECREF(FugueSingleTaskContext_cls);
    Py_XDECREF(FugueNestableTaskContext_cls);
    Py_XDECREF(FugueNestableTaskCollectionNoSelectContext_cls);
    Py_XDECREF(FugueTransformTaskContext_cls);
    Py_XDECREF(FugueProcessTaskContext_cls);
    Py_XDECREF(FugueSaveAndUseTaskContext_cls);
    Py_XDECREF(FugueRenameColumnsTaskContext_cls);
    Py_XDECREF(FugueAlterColumnsTaskContext_cls);
    Py_XDECREF(FugueDropColumnsTaskContext_cls);
    Py_XDECREF(FugueDropnaTaskContext_cls);
    Py_XDECREF(FugueFillnaTaskContext_cls);
    Py_XDECREF(FugueSampleTaskContext_cls);
    Py_XDECREF(FugueTakeTaskContext_cls);
    Py_XDECREF(FugueZipTaskContext_cls);
    Py_XDECREF(FugueCreateTaskContext_cls);
    Py_XDECREF(FugueCreateDataTaskContext_cls);
    Py_XDECREF(FugueLoadTaskContext_cls);
    Py_XDECREF(FugueOutputTaskContext_cls);
    Py_XDECREF(FuguePrintTaskContext_cls);
    Py_XDECREF(FugueSaveTaskContext_cls);
    Py_XDECREF(FugueOutputTransformTaskContext_cls);
    Py_XDECREF(FugueModuleTaskContext_cls);
    Py_XDECREF(FugueSqlEngineContext_cls);
    Py_XDECREF(FugueSingleFileContext_cls);
    Py_XDECREF(FugueLoadColumnsContext_cls);
    Py_XDECREF(FugueSaveModeContext_cls);
    Py_XDECREF(FugueFileFormatContext_cls);
    Py_XDECREF(FuguePathContext_cls);
    Py_XDECREF(FugueCheckpointDeterministicContext_cls);
    Py_XDECREF(FugueCheckpointWeakContext_cls);
    Py_XDECREF(FugueCheckpointStrongContext_cls);
    Py_XDECREF(FugueCheckpointNamespaceContext_cls);
    Py_XDECREF(FugueYieldContext_cls);
    Py_XDECREF(FugueBroadcastContext_cls);
    Py_XDECREF(FugueDataFramesDictContext_cls);
    Py_XDECREF(FugueDataFramesListContext_cls);
    Py_XDECREF(FugueDataFramePairContext_cls);
    Py_XDECREF(FugueDataFrameSourceContext_cls);
    Py_XDECREF(FugueDataFrameNestedContext_cls);
    Py_XDECREF(FugueDataFrameMemberContext_cls);
    Py_XDECREF(FugueAssignmentContext_cls);
    Py_XDECREF(FugueAssignmentSignContext_cls);
    Py_XDECREF(FugueSingleOutputExtensionCommonWildContext_cls);
    Py_XDECREF(FugueSingleOutputExtensionCommonContext_cls);
    Py_XDECREF(FugueExtensionContext_cls);
    Py_XDECREF(FugueSampleMethodContext_cls);
    Py_XDECREF(FugueZipTypeContext_cls);
    Py_XDECREF(FuguePrepartitionContext_cls);
    Py_XDECREF(FuguePartitionAlgoContext_cls);
    Py_XDECREF(FuguePartitionNumContext_cls);
    Py_XDECREF(FuguePartitionNumberContext_cls);
    Py_XDECREF(FugueParamsPairsContext_cls);
    Py_XDECREF(FugueParamsObjContext_cls);
    Py_XDECREF(FugueColsContext_cls);
    Py_XDECREF(FugueColsSortContext_cls);
    Py_XDECREF(FugueColSortContext_cls);
    Py_XDECREF(FugueColumnIdentifierContext_cls);
    Py_XDECREF(FugueRenameExpressionContext_cls);
    Py_XDECREF(FugueWildSchemaContext_cls);
    Py_XDECREF(FugueWildSchemaPairContext_cls);
    Py_XDECREF(FugueSchemaOpContext_cls);
    Py_XDECREF(FugueSchemaContext_cls);
    Py_XDECREF(FugueSchemaPairContext_cls);
    Py_XDECREF(FugueSchemaKeyContext_cls);
    Py_XDECREF(FugueSchemaSimpleTypeContext_cls);
    Py_XDECREF(FugueSchemaStructTypeContext_cls);
    Py_XDECREF(FugueSchemaListTypeContext_cls);
    Py_XDECREF(FugueRenamePairContext_cls);
    Py_XDECREF(FugueJsonContext_cls);
    Py_XDECREF(FugueJsonObjContext_cls);
    Py_XDECREF(FugueJsonPairsContext_cls);
    Py_XDECREF(FugueJsonPairContext_cls);
    Py_XDECREF(FugueJsonKeyContext_cls);
    Py_XDECREF(FugueJsonArrayContext_cls);
    Py_XDECREF(FugueJsonValueContext_cls);
    Py_XDECREF(FugueJsonNumberContext_cls);
    Py_XDECREF(FugueJsonStringContext_cls);
    Py_XDECREF(FugueJsonBoolContext_cls);
    Py_XDECREF(FugueJsonNullContext_cls);
    Py_XDECREF(FugueIdentifierContext_cls);
    Py_XDECREF(SingleStatementContext_cls);
    Py_XDECREF(SingleExpressionContext_cls);
    Py_XDECREF(SingleTableIdentifierContext_cls);
    Py_XDECREF(SingleMultipartIdentifierContext_cls);
    Py_XDECREF(SingleFunctionIdentifierContext_cls);
    Py_XDECREF(SingleDataTypeContext_cls);
    Py_XDECREF(SingleTableSchemaContext_cls);
    Py_XDECREF(ExplainContext_cls);
    Py_XDECREF(ResetConfigurationContext_cls);
    Py_XDECREF(AlterViewQueryContext_cls);
    Py_XDECREF(UseContext_cls);
    Py_XDECREF(DropNamespaceContext_cls);
    Py_XDECREF(CreateTempViewUsingContext_cls);
    Py_XDECREF(RenameTableContext_cls);
    Py_XDECREF(FailNativeCommandContext_cls);
    Py_XDECREF(ClearCacheContext_cls);
    Py_XDECREF(DropViewContext_cls);
    Py_XDECREF(ShowTablesContext_cls);
    Py_XDECREF(RecoverPartitionsContext_cls);
    Py_XDECREF(ShowCurrentNamespaceContext_cls);
    Py_XDECREF(RenameTablePartitionContext_cls);
    Py_XDECREF(RepairTableContext_cls);
    Py_XDECREF(RefreshResourceContext_cls);
    Py_XDECREF(ShowCreateTableContext_cls);
    Py_XDECREF(ShowNamespacesContext_cls);
    Py_XDECREF(ShowColumnsContext_cls);
    Py_XDECREF(ReplaceTableContext_cls);
    Py_XDECREF(AddTablePartitionContext_cls);
    Py_XDECREF(SetNamespaceLocationContext_cls);
    Py_XDECREF(RefreshTableContext_cls);
    Py_XDECREF(SetNamespacePropertiesContext_cls);
    Py_XDECREF(ManageResourceContext_cls);
    Py_XDECREF(AnalyzeContext_cls);
    Py_XDECREF(CreateHiveTableContext_cls);
    Py_XDECREF(CreateFunctionContext_cls);
    Py_XDECREF(ShowTableContext_cls);
    Py_XDECREF(HiveReplaceColumnsContext_cls);
    Py_XDECREF(CommentNamespaceContext_cls);
    Py_XDECREF(CreateTableContext_cls);
    Py_XDECREF(DmlStatementContext_cls);
    Py_XDECREF(CreateTableLikeContext_cls);
    Py_XDECREF(UncacheTableContext_cls);
    Py_XDECREF(DropFunctionContext_cls);
    Py_XDECREF(DescribeRelationContext_cls);
    Py_XDECREF(LoadDataContext_cls);
    Py_XDECREF(ShowPartitionsContext_cls);
    Py_XDECREF(DescribeFunctionContext_cls);
    Py_XDECREF(RenameTableColumnContext_cls);
    Py_XDECREF(StatementDefaultContext_cls);
    Py_XDECREF(HiveChangeColumnContext_cls);
    Py_XDECREF(DescribeQueryContext_cls);
    Py_XDECREF(TruncateTableContext_cls);
    Py_XDECREF(SetTableSerDeContext_cls);
    Py_XDECREF(CreateViewContext_cls);
    Py_XDECREF(DropTablePartitionsContext_cls);
    Py_XDECREF(SetConfigurationContext_cls);
    Py_XDECREF(DropTableContext_cls);
    Py_XDECREF(DescribeNamespaceContext_cls);
    Py_XDECREF(AlterTableAlterColumnContext_cls);
    Py_XDECREF(CommentTableContext_cls);
    Py_XDECREF(CreateNamespaceContext_cls);
    Py_XDECREF(ShowTblPropertiesContext_cls);
    Py_XDECREF(UnsetTablePropertiesContext_cls);
    Py_XDECREF(SetTableLocationContext_cls);
    Py_XDECREF(DropTableColumnsContext_cls);
    Py_XDECREF(ShowViewsContext_cls);
    Py_XDECREF(ShowFunctionsContext_cls);
    Py_XDECREF(CacheTableContext_cls);
    Py_XDECREF(AddTableColumnsContext_cls);
    Py_XDECREF(SetTablePropertiesContext_cls);
    Py_XDECREF(UnsupportedHiveNativeCommandsContext_cls);
    Py_XDECREF(CreateTableHeaderContext_cls);
    Py_XDECREF(ReplaceTableHeaderContext_cls);
    Py_XDECREF(BucketSpecContext_cls);
    Py_XDECREF(SkewSpecContext_cls);
    Py_XDECREF(LocationSpecContext_cls);
    Py_XDECREF(CommentSpecContext_cls);
    Py_XDECREF(QueryContext_cls);
    Py_XDECREF(InsertOverwriteHiveDirContext_cls);
    Py_XDECREF(InsertOverwriteDirContext_cls);
    Py_XDECREF(InsertOverwriteTableContext_cls);
    Py_XDECREF(InsertIntoTableContext_cls);
    Py_XDECREF(PartitionSpecLocationContext_cls);
    Py_XDECREF(PartitionSpecContext_cls);
    Py_XDECREF(PartitionValContext_cls);
    Py_XDECREF(TheNamespaceContext_cls);
    Py_XDECREF(DescribeFuncNameContext_cls);
    Py_XDECREF(DescribeColNameContext_cls);
    Py_XDECREF(CtesContext_cls);
    Py_XDECREF(NamedQueryContext_cls);
    Py_XDECREF(TableProviderContext_cls);
    Py_XDECREF(CreateTableClausesContext_cls);
    Py_XDECREF(TablePropertyListContext_cls);
    Py_XDECREF(TablePropertyContext_cls);
    Py_XDECREF(TablePropertyKeyContext_cls);
    Py_XDECREF(TablePropertyValueContext_cls);
    Py_XDECREF(ConstantListContext_cls);
    Py_XDECREF(NestedConstantListContext_cls);
    Py_XDECREF(CreateFileFormatContext_cls);
    Py_XDECREF(TableFileFormatContext_cls);
    Py_XDECREF(GenericFileFormatContext_cls);
    Py_XDECREF(StorageHandlerContext_cls);
    Py_XDECREF(ResourceContext_cls);
    Py_XDECREF(DeleteFromTableContext_cls);
    Py_XDECREF(SingleInsertQueryContext_cls);
    Py_XDECREF(MultiInsertQueryContext_cls);
    Py_XDECREF(UpdateTableContext_cls);
    Py_XDECREF(MergeIntoTableContext_cls);
    Py_XDECREF(QueryOrganizationContext_cls);
    Py_XDECREF(MultiInsertQueryBodyContext_cls);
    Py_XDECREF(QueryTermDefaultContext_cls);
    Py_XDECREF(FugueTermContext_cls);
    Py_XDECREF(SetOperationContext_cls);
    Py_XDECREF(QueryPrimaryDefaultContext_cls);
    Py_XDECREF(InlineTableDefault1Context_cls);
    Py_XDECREF(FromStmtContext_cls);
    Py_XDECREF(TableContext_cls);
    Py_XDECREF(SortItemContext_cls);
    Py_XDECREF(FromStatementContext_cls);
    Py_XDECREF(FromStatementBodyContext_cls);
    Py_XDECREF(RegularQuerySpecificationContext_cls);
    Py_XDECREF(TransformQuerySpecificationContext_cls);
    Py_XDECREF(OptionalFromClauseContext_cls);
    Py_XDECREF(TransformClauseContext_cls);
    Py_XDECREF(SelectClauseContext_cls);
    Py_XDECREF(SetClauseContext_cls);
    Py_XDECREF(MatchedClauseContext_cls);
    Py_XDECREF(NotMatchedClauseContext_cls);
    Py_XDECREF(MatchedActionContext_cls);
    Py_XDECREF(NotMatchedActionContext_cls);
    Py_XDECREF(AssignmentListContext_cls);
    Py_XDECREF(AssignmentContext_cls);
    Py_XDECREF(WhereClauseContext_cls);
    Py_XDECREF(HavingClauseContext_cls);
    Py_XDECREF(HintContext_cls);
    Py_XDECREF(HintStatementContext_cls);
    Py_XDECREF(FromClauseContext_cls);
    Py_XDECREF(AggregationClauseContext_cls);
    Py_XDECREF(GroupingSetContext_cls);
    Py_XDECREF(PivotClauseContext_cls);
    Py_XDECREF(PivotColumnContext_cls);
    Py_XDECREF(PivotValueContext_cls);
    Py_XDECREF(LateralViewContext_cls);
    Py_XDECREF(SetQuantifierContext_cls);
    Py_XDECREF(RelationContext_cls);
    Py_XDECREF(JoinRelationContext_cls);
    Py_XDECREF(JoinTypeContext_cls);
    Py_XDECREF(JoinCriteriaContext_cls);
    Py_XDECREF(SampleContext_cls);
    Py_XDECREF(SampleByRowsContext_cls);
    Py_XDECREF(SampleByPercentileContext_cls);
    Py_XDECREF(SampleByBucketContext_cls);
    Py_XDECREF(SampleByBytesContext_cls);
    Py_XDECREF(IdentifierListContext_cls);
    Py_XDECREF(IdentifierSeqContext_cls);
    Py_XDECREF(OrderedIdentifierListContext_cls);
    Py_XDECREF(OrderedIdentifierContext_cls);
    Py_XDECREF(IdentifierCommentListContext_cls);
    Py_XDECREF(IdentifierCommentContext_cls);
    Py_XDECREF(TableValuedFunctionContext_cls);
    Py_XDECREF(InlineTableDefault2Context_cls);
    Py_XDECREF(AliasedRelationContext_cls);
    Py_XDECREF(AliasedQueryContext_cls);
    Py_XDECREF(TableNameContext_cls);
    Py_XDECREF(InlineTableContext_cls);
    Py_XDECREF(FunctionTableContext_cls);
    Py_XDECREF(TableAliasContext_cls);
    Py_XDECREF(RowFormatSerdeContext_cls);
    Py_XDECREF(RowFormatDelimitedContext_cls);
    Py_XDECREF(MultipartIdentifierListContext_cls);
    Py_XDECREF(MultipartIdentifierContext_cls);
    Py_XDECREF(TableIdentifierContext_cls);
    Py_XDECREF(FunctionIdentifierContext_cls);
    Py_XDECREF(NamedExpressionContext_cls);
    Py_XDECREF(NamedExpressionSeqContext_cls);
    Py_XDECREF(TransformListContext_cls);
    Py_XDECREF(IdentityTransformContext_cls);
    Py_XDECREF(ApplyTransformContext_cls);
    Py_XDECREF(TransformArgumentContext_cls);
    Py_XDECREF(ExpressionContext_cls);
    Py_XDECREF(LogicalNotContext_cls);
    Py_XDECREF(PredicatedContext_cls);
    Py_XDECREF(ExistsContext_cls);
    Py_XDECREF(LogicalBinaryContext_cls);
    Py_XDECREF(PredicateContext_cls);
    Py_XDECREF(ValueExpressionDefaultContext_cls);
    Py_XDECREF(ComparisonContext_cls);
    Py_XDECREF(ArithmeticBinaryContext_cls);
    Py_XDECREF(ArithmeticUnaryContext_cls);
    Py_XDECREF(StructContext_cls);
    Py_XDECREF(DereferenceContext_cls);
    Py_XDECREF(SimpleCaseContext_cls);
    Py_XDECREF(ColumnReferenceContext_cls);
    Py_XDECREF(RowConstructorContext_cls);
    Py_XDECREF(LastContext_cls);
    Py_XDECREF(StarContext_cls);
    Py_XDECREF(OverlayContext_cls);
    Py_XDECREF(SubscriptContext_cls);
    Py_XDECREF(SubqueryExpressionContext_cls);
    Py_XDECREF(SubstringContext_cls);
    Py_XDECREF(CurrentDatetimeContext_cls);
    Py_XDECREF(CastContext_cls);
    Py_XDECREF(ConstantDefaultContext_cls);
    Py_XDECREF(LambdaContext_cls);
    Py_XDECREF(ParenthesizedExpressionContext_cls);
    Py_XDECREF(ExtractContext_cls);
    Py_XDECREF(TrimContext_cls);
    Py_XDECREF(FunctionCallContext_cls);
    Py_XDECREF(SearchedCaseContext_cls);
    Py_XDECREF(PositionContext_cls);
    Py_XDECREF(FirstContext_cls);
    Py_XDECREF(NullLiteralContext_cls);
    Py_XDECREF(StringLiteralContext_cls);
    Py_XDECREF(TypeConstructorContext_cls);
    Py_XDECREF(IntervalLiteralContext_cls);
    Py_XDECREF(NumericLiteralContext_cls);
    Py_XDECREF(BooleanLiteralContext_cls);
    Py_XDECREF(ComparisonOperatorContext_cls);
    Py_XDECREF(ComparisonEqualOperatorContext_cls);
    Py_XDECREF(ArithmeticOperatorContext_cls);
    Py_XDECREF(PredicateOperatorContext_cls);
    Py_XDECREF(BooleanValueContext_cls);
    Py_XDECREF(IntervalContext_cls);
    Py_XDECREF(ErrorCapturingMultiUnitsIntervalContext_cls);
    Py_XDECREF(MultiUnitsIntervalContext_cls);
    Py_XDECREF(ErrorCapturingUnitToUnitIntervalContext_cls);
    Py_XDECREF(UnitToUnitIntervalContext_cls);
    Py_XDECREF(IntervalValueContext_cls);
    Py_XDECREF(IntervalUnitContext_cls);
    Py_XDECREF(ColPositionContext_cls);
    Py_XDECREF(ComplexDataTypeContext_cls);
    Py_XDECREF(PrimitiveDataTypeContext_cls);
    Py_XDECREF(QualifiedColTypeWithPositionListContext_cls);
    Py_XDECREF(QualifiedColTypeWithPositionContext_cls);
    Py_XDECREF(ColTypeListContext_cls);
    Py_XDECREF(ColTypeContext_cls);
    Py_XDECREF(ComplexColTypeListContext_cls);
    Py_XDECREF(ComplexColTypeContext_cls);
    Py_XDECREF(WhenClauseContext_cls);
    Py_XDECREF(WindowClauseContext_cls);
    Py_XDECREF(NamedWindowContext_cls);
    Py_XDECREF(WindowRefContext_cls);
    Py_XDECREF(WindowDefContext_cls);
    Py_XDECREF(WindowFrameContext_cls);
    Py_XDECREF(FrameBoundContext_cls);
    Py_XDECREF(QualifiedNameListContext_cls);
    Py_XDECREF(FunctionNameContext_cls);
    Py_XDECREF(QualifiedNameContext_cls);
    Py_XDECREF(ErrorCapturingIdentifierContext_cls);
    Py_XDECREF(ErrorIdentContext_cls);
    Py_XDECREF(IdentifierContext_cls);
    Py_XDECREF(QuotedIdentifierAlternativeContext_cls);
    Py_XDECREF(UnquotedIdentifierContext_cls);
    Py_XDECREF(QuotedIdentifierContext_cls);
    Py_XDECREF(DecimalLiteralContext_cls);
    Py_XDECREF(BigIntLiteralContext_cls);
    Py_XDECREF(TinyIntLiteralContext_cls);
    Py_XDECREF(LegacyDecimalLiteralContext_cls);
    Py_XDECREF(BigDecimalLiteralContext_cls);
    Py_XDECREF(ExponentLiteralContext_cls);
    Py_XDECREF(DoubleLiteralContext_cls);
    Py_XDECREF(IntegerLiteralContext_cls);
    Py_XDECREF(SmallIntLiteralContext_cls);
    Py_XDECREF(AlterColumnActionContext_cls);
    Py_XDECREF(AnsiNonReservedContext_cls);
    Py_XDECREF(StrictNonReservedContext_cls);
    Py_XDECREF(NonReservedContext_cls);
}


antlrcpp::Any SA_fugue_sqlTranslator::visitFugueLanguage(fugue_sqlParser::FugueLanguageContext *ctx){
    if(!FugueLanguageContext_cls) FugueLanguageContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueLanguageContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueLanguageContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSingleStatement(fugue_sqlParser::FugueSingleStatementContext *ctx){
    if(!FugueSingleStatementContext_cls) FugueSingleStatementContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSingleStatementContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSingleStatementContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSingleTask(fugue_sqlParser::FugueSingleTaskContext *ctx){
    if(!FugueSingleTaskContext_cls) FugueSingleTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSingleTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSingleTaskContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueNestableTask(fugue_sqlParser::FugueNestableTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"assign", static_cast<void*>(ctx->assign)},
        {"q", static_cast<void*>(ctx->q)},
        {"checkpoint", static_cast<void*>(ctx->checkpoint)},
        {"broadcast", static_cast<void*>(ctx->broadcast)},
        {"y", static_cast<void*>(ctx->y)}
    };
    if(!FugueNestableTaskContext_cls) FugueNestableTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueNestableTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueNestableTaskContext_cls, labels, 5);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueNestableTaskCollectionNoSelect(fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext *ctx){
    if(!FugueNestableTaskCollectionNoSelectContext_cls) FugueNestableTaskCollectionNoSelectContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueNestableTaskCollectionNoSelectContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueNestableTaskCollectionNoSelectContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueTransformTask(fugue_sqlParser::FugueTransformTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"dfs", static_cast<void*>(ctx->dfs)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"params", static_cast<void*>(ctx->params)},
        {"callback", static_cast<void*>(ctx->callback)}
    };
    if(!FugueTransformTaskContext_cls) FugueTransformTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueTransformTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueTransformTaskContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueProcessTask(fugue_sqlParser::FugueProcessTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"dfs", static_cast<void*>(ctx->dfs)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueProcessTaskContext_cls) FugueProcessTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueProcessTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueProcessTaskContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSaveAndUseTask(fugue_sqlParser::FugueSaveAndUseTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"df", static_cast<void*>(ctx->df)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"m", static_cast<void*>(ctx->m)},
        {"single", static_cast<void*>(ctx->single)},
        {"fmt", static_cast<void*>(ctx->fmt)},
        {"path", static_cast<void*>(ctx->path)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueSaveAndUseTaskContext_cls) FugueSaveAndUseTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSaveAndUseTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSaveAndUseTaskContext_cls, labels, 7);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueRenameColumnsTask(fugue_sqlParser::FugueRenameColumnsTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"cols", static_cast<void*>(ctx->cols)},
        {"df", static_cast<void*>(ctx->df)}
    };
    if(!FugueRenameColumnsTaskContext_cls) FugueRenameColumnsTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueRenameColumnsTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueRenameColumnsTaskContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueAlterColumnsTask(fugue_sqlParser::FugueAlterColumnsTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"cols", static_cast<void*>(ctx->cols)},
        {"df", static_cast<void*>(ctx->df)}
    };
    if(!FugueAlterColumnsTaskContext_cls) FugueAlterColumnsTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueAlterColumnsTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueAlterColumnsTaskContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDropColumnsTask(fugue_sqlParser::FugueDropColumnsTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"cols", static_cast<void*>(ctx->cols)},
        {"df", static_cast<void*>(ctx->df)}
    };
    if(!FugueDropColumnsTaskContext_cls) FugueDropColumnsTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDropColumnsTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDropColumnsTaskContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDropnaTask(fugue_sqlParser::FugueDropnaTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"how", static_cast<void*>(ctx->how)},
        {"cols", static_cast<void*>(ctx->cols)},
        {"df", static_cast<void*>(ctx->df)}
    };
    if(!FugueDropnaTaskContext_cls) FugueDropnaTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDropnaTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDropnaTaskContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueFillnaTask(fugue_sqlParser::FugueFillnaTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"params", static_cast<void*>(ctx->params)},
        {"df", static_cast<void*>(ctx->df)}
    };
    if(!FugueFillnaTaskContext_cls) FugueFillnaTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueFillnaTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueFillnaTaskContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSampleTask(fugue_sqlParser::FugueSampleTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"method", static_cast<void*>(ctx->method)},
        {"seed", static_cast<void*>(ctx->seed)},
        {"df", static_cast<void*>(ctx->df)}
    };
    if(!FugueSampleTaskContext_cls) FugueSampleTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSampleTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSampleTaskContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueTakeTask(fugue_sqlParser::FugueTakeTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"rows", static_cast<void*>(ctx->rows)},
        {"df", static_cast<void*>(ctx->df)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"presort", static_cast<void*>(ctx->presort)},
        {"na_position", static_cast<void*>(ctx->na_position)}
    };
    if(!FugueTakeTaskContext_cls) FugueTakeTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueTakeTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueTakeTaskContext_cls, labels, 5);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueZipTask(fugue_sqlParser::FugueZipTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"dfs", static_cast<void*>(ctx->dfs)},
        {"how", static_cast<void*>(ctx->how)},
        {"by", static_cast<void*>(ctx->by)},
        {"presort", static_cast<void*>(ctx->presort)}
    };
    if(!FugueZipTaskContext_cls) FugueZipTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueZipTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueZipTaskContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueCreateTask(fugue_sqlParser::FugueCreateTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueCreateTaskContext_cls) FugueCreateTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueCreateTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueCreateTaskContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueCreateDataTask(fugue_sqlParser::FugueCreateDataTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"data", static_cast<void*>(ctx->data)},
        {"schema", static_cast<void*>(ctx->schema)}
    };
    if(!FugueCreateDataTaskContext_cls) FugueCreateDataTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueCreateDataTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueCreateDataTaskContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueLoadTask(fugue_sqlParser::FugueLoadTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"fmt", static_cast<void*>(ctx->fmt)},
        {"path", static_cast<void*>(ctx->path)},
        {"params", static_cast<void*>(ctx->params)},
        {"columns", static_cast<void*>(ctx->columns)}
    };
    if(!FugueLoadTaskContext_cls) FugueLoadTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueLoadTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueLoadTaskContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueOutputTask(fugue_sqlParser::FugueOutputTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"dfs", static_cast<void*>(ctx->dfs)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"fugueUsing", static_cast<void*>(ctx->fugueUsing)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueOutputTaskContext_cls) FugueOutputTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueOutputTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueOutputTaskContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFuguePrintTask(fugue_sqlParser::FuguePrintTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"rows", static_cast<void*>(ctx->rows)},
        {"dfs", static_cast<void*>(ctx->dfs)},
        {"count", static_cast<void*>(ctx->count)},
        {"title", static_cast<void*>(ctx->title)}
    };
    if(!FuguePrintTaskContext_cls) FuguePrintTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FuguePrintTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FuguePrintTaskContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSaveTask(fugue_sqlParser::FugueSaveTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"df", static_cast<void*>(ctx->df)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"m", static_cast<void*>(ctx->m)},
        {"single", static_cast<void*>(ctx->single)},
        {"fmt", static_cast<void*>(ctx->fmt)},
        {"path", static_cast<void*>(ctx->path)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueSaveTaskContext_cls) FugueSaveTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSaveTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSaveTaskContext_cls, labels, 7);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueOutputTransformTask(fugue_sqlParser::FugueOutputTransformTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"dfs", static_cast<void*>(ctx->dfs)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"fugueUsing", static_cast<void*>(ctx->fugueUsing)},
        {"params", static_cast<void*>(ctx->params)},
        {"callback", static_cast<void*>(ctx->callback)}
    };
    if(!FugueOutputTransformTaskContext_cls) FugueOutputTransformTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueOutputTransformTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueOutputTransformTaskContext_cls, labels, 5);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueModuleTask(fugue_sqlParser::FugueModuleTaskContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"assign", static_cast<void*>(ctx->assign)},
        {"dfs", static_cast<void*>(ctx->dfs)},
        {"fugueUsing", static_cast<void*>(ctx->fugueUsing)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueModuleTaskContext_cls) FugueModuleTaskContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueModuleTaskContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueModuleTaskContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSqlEngine(fugue_sqlParser::FugueSqlEngineContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"fugueUsing", static_cast<void*>(ctx->fugueUsing)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueSqlEngineContext_cls) FugueSqlEngineContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSqlEngineContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSqlEngineContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSingleFile(fugue_sqlParser::FugueSingleFileContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"single", static_cast<void*>(ctx->single)}
    };
    if(!FugueSingleFileContext_cls) FugueSingleFileContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSingleFileContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSingleFileContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueLoadColumns(fugue_sqlParser::FugueLoadColumnsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"schema", static_cast<void*>(ctx->schema)},
        {"cols", static_cast<void*>(ctx->cols)}
    };
    if(!FugueLoadColumnsContext_cls) FugueLoadColumnsContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueLoadColumnsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueLoadColumnsContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSaveMode(fugue_sqlParser::FugueSaveModeContext *ctx){
    if(!FugueSaveModeContext_cls) FugueSaveModeContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSaveModeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSaveModeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueFileFormat(fugue_sqlParser::FugueFileFormatContext *ctx){
    if(!FugueFileFormatContext_cls) FugueFileFormatContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueFileFormatContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueFileFormatContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFuguePath(fugue_sqlParser::FuguePathContext *ctx){
    if(!FuguePathContext_cls) FuguePathContext_cls = PyObject_GetAttrString(translator->parser_cls, "FuguePathContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FuguePathContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueCheckpointDeterministic(fugue_sqlParser::FugueCheckpointDeterministicContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"ns", static_cast<void*>(ctx->ns)},
        {"partition", static_cast<void*>(ctx->partition)},
        {"single", static_cast<void*>(ctx->single)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueCheckpointDeterministicContext_cls) FugueCheckpointDeterministicContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueCheckpointDeterministicContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueCheckpointDeterministicContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueCheckpointWeak(fugue_sqlParser::FugueCheckpointWeakContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueCheckpointWeakContext_cls) FugueCheckpointWeakContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueCheckpointWeakContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueCheckpointWeakContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueCheckpointStrong(fugue_sqlParser::FugueCheckpointStrongContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"partition", static_cast<void*>(ctx->partition)},
        {"single", static_cast<void*>(ctx->single)},
        {"params", static_cast<void*>(ctx->params)}
    };
    if(!FugueCheckpointStrongContext_cls) FugueCheckpointStrongContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueCheckpointStrongContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueCheckpointStrongContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueCheckpointNamespace(fugue_sqlParser::FugueCheckpointNamespaceContext *ctx){
    if(!FugueCheckpointNamespaceContext_cls) FugueCheckpointNamespaceContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueCheckpointNamespaceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueCheckpointNamespaceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueYield(fugue_sqlParser::FugueYieldContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)}
    };
    if(!FugueYieldContext_cls) FugueYieldContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueYieldContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueYieldContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueBroadcast(fugue_sqlParser::FugueBroadcastContext *ctx){
    if(!FugueBroadcastContext_cls) FugueBroadcastContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueBroadcastContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueBroadcastContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDataFramesDict(fugue_sqlParser::FugueDataFramesDictContext *ctx){
    if(!FugueDataFramesDictContext_cls) FugueDataFramesDictContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDataFramesDictContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDataFramesDictContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDataFramesList(fugue_sqlParser::FugueDataFramesListContext *ctx){
    if(!FugueDataFramesListContext_cls) FugueDataFramesListContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDataFramesListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDataFramesListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDataFramePair(fugue_sqlParser::FugueDataFramePairContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"key", static_cast<void*>(ctx->key)},
        {"value", static_cast<void*>(ctx->value)}
    };
    if(!FugueDataFramePairContext_cls) FugueDataFramePairContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDataFramePairContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDataFramePairContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDataFrameSource(fugue_sqlParser::FugueDataFrameSourceContext *ctx){
    if(!FugueDataFrameSourceContext_cls) FugueDataFrameSourceContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDataFrameSourceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDataFrameSourceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDataFrameNested(fugue_sqlParser::FugueDataFrameNestedContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"task", static_cast<void*>(ctx->task)}
    };
    if(!FugueDataFrameNestedContext_cls) FugueDataFrameNestedContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDataFrameNestedContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDataFrameNestedContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueDataFrameMember(fugue_sqlParser::FugueDataFrameMemberContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"index", static_cast<void*>(ctx->index)},
        {"key", static_cast<void*>(ctx->key)}
    };
    if(!FugueDataFrameMemberContext_cls) FugueDataFrameMemberContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueDataFrameMemberContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueDataFrameMemberContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueAssignment(fugue_sqlParser::FugueAssignmentContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"varname", static_cast<void*>(ctx->varname)},
        {"sign", static_cast<void*>(ctx->sign)}
    };
    if(!FugueAssignmentContext_cls) FugueAssignmentContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueAssignmentContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueAssignmentContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueAssignmentSign(fugue_sqlParser::FugueAssignmentSignContext *ctx){
    if(!FugueAssignmentSignContext_cls) FugueAssignmentSignContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueAssignmentSignContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueAssignmentSignContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSingleOutputExtensionCommonWild(fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"fugueUsing", static_cast<void*>(ctx->fugueUsing)},
        {"params", static_cast<void*>(ctx->params)},
        {"schema", static_cast<void*>(ctx->schema)}
    };
    if(!FugueSingleOutputExtensionCommonWildContext_cls) FugueSingleOutputExtensionCommonWildContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSingleOutputExtensionCommonWildContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSingleOutputExtensionCommonWildContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSingleOutputExtensionCommon(fugue_sqlParser::FugueSingleOutputExtensionCommonContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"fugueUsing", static_cast<void*>(ctx->fugueUsing)},
        {"params", static_cast<void*>(ctx->params)},
        {"schema", static_cast<void*>(ctx->schema)}
    };
    if(!FugueSingleOutputExtensionCommonContext_cls) FugueSingleOutputExtensionCommonContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSingleOutputExtensionCommonContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSingleOutputExtensionCommonContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueExtension(fugue_sqlParser::FugueExtensionContext *ctx){
    if(!FugueExtensionContext_cls) FugueExtensionContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueExtensionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueExtensionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSampleMethod(fugue_sqlParser::FugueSampleMethodContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"percentage", static_cast<void*>(ctx->percentage)},
        {"rows", static_cast<void*>(ctx->rows)}
    };
    if(!FugueSampleMethodContext_cls) FugueSampleMethodContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSampleMethodContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSampleMethodContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueZipType(fugue_sqlParser::FugueZipTypeContext *ctx){
    if(!FugueZipTypeContext_cls) FugueZipTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueZipTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueZipTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFuguePrepartition(fugue_sqlParser::FuguePrepartitionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"algo", static_cast<void*>(ctx->algo)},
        {"num", static_cast<void*>(ctx->num)},
        {"by", static_cast<void*>(ctx->by)},
        {"presort", static_cast<void*>(ctx->presort)}
    };
    if(!FuguePrepartitionContext_cls) FuguePrepartitionContext_cls = PyObject_GetAttrString(translator->parser_cls, "FuguePrepartitionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FuguePrepartitionContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFuguePartitionAlgo(fugue_sqlParser::FuguePartitionAlgoContext *ctx){
    if(!FuguePartitionAlgoContext_cls) FuguePartitionAlgoContext_cls = PyObject_GetAttrString(translator->parser_cls, "FuguePartitionAlgoContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FuguePartitionAlgoContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFuguePartitionNum(fugue_sqlParser::FuguePartitionNumContext *ctx){
    if(!FuguePartitionNumContext_cls) FuguePartitionNumContext_cls = PyObject_GetAttrString(translator->parser_cls, "FuguePartitionNumContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FuguePartitionNumContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFuguePartitionNumber(fugue_sqlParser::FuguePartitionNumberContext *ctx){
    if(!FuguePartitionNumberContext_cls) FuguePartitionNumberContext_cls = PyObject_GetAttrString(translator->parser_cls, "FuguePartitionNumberContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FuguePartitionNumberContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueParamsPairs(fugue_sqlParser::FugueParamsPairsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"pairs", static_cast<void*>(ctx->pairs)}
    };
    if(!FugueParamsPairsContext_cls) FugueParamsPairsContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueParamsPairsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueParamsPairsContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueParamsObj(fugue_sqlParser::FugueParamsObjContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"obj", static_cast<void*>(ctx->obj)}
    };
    if(!FugueParamsObjContext_cls) FugueParamsObjContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueParamsObjContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueParamsObjContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueCols(fugue_sqlParser::FugueColsContext *ctx){
    if(!FugueColsContext_cls) FugueColsContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueColsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueColsContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueColsSort(fugue_sqlParser::FugueColsSortContext *ctx){
    if(!FugueColsSortContext_cls) FugueColsSortContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueColsSortContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueColsSortContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueColSort(fugue_sqlParser::FugueColSortContext *ctx){
    if(!FugueColSortContext_cls) FugueColSortContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueColSortContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueColSortContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueColumnIdentifier(fugue_sqlParser::FugueColumnIdentifierContext *ctx){
    if(!FugueColumnIdentifierContext_cls) FugueColumnIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueColumnIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueColumnIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueRenameExpression(fugue_sqlParser::FugueRenameExpressionContext *ctx){
    if(!FugueRenameExpressionContext_cls) FugueRenameExpressionContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueRenameExpressionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueRenameExpressionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueWildSchema(fugue_sqlParser::FugueWildSchemaContext *ctx){
    if(!FugueWildSchemaContext_cls) FugueWildSchemaContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueWildSchemaContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueWildSchemaContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueWildSchemaPair(fugue_sqlParser::FugueWildSchemaPairContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"pair", static_cast<void*>(ctx->pair)}
    };
    if(!FugueWildSchemaPairContext_cls) FugueWildSchemaPairContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueWildSchemaPairContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueWildSchemaPairContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSchemaOp(fugue_sqlParser::FugueSchemaOpContext *ctx){
    if(!FugueSchemaOpContext_cls) FugueSchemaOpContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSchemaOpContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSchemaOpContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSchema(fugue_sqlParser::FugueSchemaContext *ctx){
    if(!FugueSchemaContext_cls) FugueSchemaContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSchemaContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSchemaContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSchemaPair(fugue_sqlParser::FugueSchemaPairContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"key", static_cast<void*>(ctx->key)},
        {"value", static_cast<void*>(ctx->value)}
    };
    if(!FugueSchemaPairContext_cls) FugueSchemaPairContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSchemaPairContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSchemaPairContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSchemaKey(fugue_sqlParser::FugueSchemaKeyContext *ctx){
    if(!FugueSchemaKeyContext_cls) FugueSchemaKeyContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSchemaKeyContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSchemaKeyContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSchemaSimpleType(fugue_sqlParser::FugueSchemaSimpleTypeContext *ctx){
    if(!FugueSchemaSimpleTypeContext_cls) FugueSchemaSimpleTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSchemaSimpleTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSchemaSimpleTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSchemaStructType(fugue_sqlParser::FugueSchemaStructTypeContext *ctx){
    if(!FugueSchemaStructTypeContext_cls) FugueSchemaStructTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSchemaStructTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSchemaStructTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueSchemaListType(fugue_sqlParser::FugueSchemaListTypeContext *ctx){
    if(!FugueSchemaListTypeContext_cls) FugueSchemaListTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueSchemaListTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueSchemaListTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueRenamePair(fugue_sqlParser::FugueRenamePairContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"key", static_cast<void*>(ctx->key)},
        {"value", static_cast<void*>(ctx->value)}
    };
    if(!FugueRenamePairContext_cls) FugueRenamePairContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueRenamePairContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueRenamePairContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJson(fugue_sqlParser::FugueJsonContext *ctx){
    if(!FugueJsonContext_cls) FugueJsonContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonObj(fugue_sqlParser::FugueJsonObjContext *ctx){
    if(!FugueJsonObjContext_cls) FugueJsonObjContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonObjContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonObjContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonPairs(fugue_sqlParser::FugueJsonPairsContext *ctx){
    if(!FugueJsonPairsContext_cls) FugueJsonPairsContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonPairsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonPairsContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonPair(fugue_sqlParser::FugueJsonPairContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"key", static_cast<void*>(ctx->key)},
        {"value", static_cast<void*>(ctx->value)}
    };
    if(!FugueJsonPairContext_cls) FugueJsonPairContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonPairContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonPairContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonKey(fugue_sqlParser::FugueJsonKeyContext *ctx){
    if(!FugueJsonKeyContext_cls) FugueJsonKeyContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonKeyContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonKeyContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonArray(fugue_sqlParser::FugueJsonArrayContext *ctx){
    if(!FugueJsonArrayContext_cls) FugueJsonArrayContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonArrayContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonArrayContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonValue(fugue_sqlParser::FugueJsonValueContext *ctx){
    if(!FugueJsonValueContext_cls) FugueJsonValueContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonValueContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonValueContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonNumber(fugue_sqlParser::FugueJsonNumberContext *ctx){
    if(!FugueJsonNumberContext_cls) FugueJsonNumberContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonNumberContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonNumberContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonString(fugue_sqlParser::FugueJsonStringContext *ctx){
    if(!FugueJsonStringContext_cls) FugueJsonStringContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonStringContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonStringContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonBool(fugue_sqlParser::FugueJsonBoolContext *ctx){
    if(!FugueJsonBoolContext_cls) FugueJsonBoolContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonBoolContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonBoolContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueJsonNull(fugue_sqlParser::FugueJsonNullContext *ctx){
    if(!FugueJsonNullContext_cls) FugueJsonNullContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueJsonNullContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueJsonNullContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueIdentifier(fugue_sqlParser::FugueIdentifierContext *ctx){
    if(!FugueIdentifierContext_cls) FugueIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleStatement(fugue_sqlParser::SingleStatementContext *ctx){
    if(!SingleStatementContext_cls) SingleStatementContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleStatementContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleStatementContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleExpression(fugue_sqlParser::SingleExpressionContext *ctx){
    if(!SingleExpressionContext_cls) SingleExpressionContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleExpressionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleExpressionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleTableIdentifier(fugue_sqlParser::SingleTableIdentifierContext *ctx){
    if(!SingleTableIdentifierContext_cls) SingleTableIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleTableIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleTableIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleMultipartIdentifier(fugue_sqlParser::SingleMultipartIdentifierContext *ctx){
    if(!SingleMultipartIdentifierContext_cls) SingleMultipartIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleMultipartIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleMultipartIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleFunctionIdentifier(fugue_sqlParser::SingleFunctionIdentifierContext *ctx){
    if(!SingleFunctionIdentifierContext_cls) SingleFunctionIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleFunctionIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleFunctionIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleDataType(fugue_sqlParser::SingleDataTypeContext *ctx){
    if(!SingleDataTypeContext_cls) SingleDataTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleDataTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleDataTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleTableSchema(fugue_sqlParser::SingleTableSchemaContext *ctx){
    if(!SingleTableSchemaContext_cls) SingleTableSchemaContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleTableSchemaContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleTableSchemaContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitExplain(fugue_sqlParser::ExplainContext *ctx){
    if(!ExplainContext_cls) ExplainContext_cls = PyObject_GetAttrString(translator->parser_cls, "ExplainContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ExplainContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitResetConfiguration(fugue_sqlParser::ResetConfigurationContext *ctx){
    if(!ResetConfigurationContext_cls) ResetConfigurationContext_cls = PyObject_GetAttrString(translator->parser_cls, "ResetConfigurationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ResetConfigurationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAlterViewQuery(fugue_sqlParser::AlterViewQueryContext *ctx){
    if(!AlterViewQueryContext_cls) AlterViewQueryContext_cls = PyObject_GetAttrString(translator->parser_cls, "AlterViewQueryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AlterViewQueryContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitUse(fugue_sqlParser::UseContext *ctx){
    if(!UseContext_cls) UseContext_cls = PyObject_GetAttrString(translator->parser_cls, "UseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, UseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDropNamespace(fugue_sqlParser::DropNamespaceContext *ctx){
    if(!DropNamespaceContext_cls) DropNamespaceContext_cls = PyObject_GetAttrString(translator->parser_cls, "DropNamespaceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DropNamespaceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateTempViewUsing(fugue_sqlParser::CreateTempViewUsingContext *ctx){
    if(!CreateTempViewUsingContext_cls) CreateTempViewUsingContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateTempViewUsingContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateTempViewUsingContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRenameTable(fugue_sqlParser::RenameTableContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"ifrom", static_cast<void*>(ctx->ifrom)},
        {"to", static_cast<void*>(ctx->to)}
    };
    if(!RenameTableContext_cls) RenameTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "RenameTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RenameTableContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFailNativeCommand(fugue_sqlParser::FailNativeCommandContext *ctx){
    if(!FailNativeCommandContext_cls) FailNativeCommandContext_cls = PyObject_GetAttrString(translator->parser_cls, "FailNativeCommandContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FailNativeCommandContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitClearCache(fugue_sqlParser::ClearCacheContext *ctx){
    if(!ClearCacheContext_cls) ClearCacheContext_cls = PyObject_GetAttrString(translator->parser_cls, "ClearCacheContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ClearCacheContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDropView(fugue_sqlParser::DropViewContext *ctx){
    if(!DropViewContext_cls) DropViewContext_cls = PyObject_GetAttrString(translator->parser_cls, "DropViewContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DropViewContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowTables(fugue_sqlParser::ShowTablesContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"pattern", static_cast<void*>(ctx->pattern)}
    };
    if(!ShowTablesContext_cls) ShowTablesContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowTablesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowTablesContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRecoverPartitions(fugue_sqlParser::RecoverPartitionsContext *ctx){
    if(!RecoverPartitionsContext_cls) RecoverPartitionsContext_cls = PyObject_GetAttrString(translator->parser_cls, "RecoverPartitionsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RecoverPartitionsContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowCurrentNamespace(fugue_sqlParser::ShowCurrentNamespaceContext *ctx){
    if(!ShowCurrentNamespaceContext_cls) ShowCurrentNamespaceContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowCurrentNamespaceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowCurrentNamespaceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRenameTablePartition(fugue_sqlParser::RenameTablePartitionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"ifrom", static_cast<void*>(ctx->ifrom)},
        {"to", static_cast<void*>(ctx->to)}
    };
    if(!RenameTablePartitionContext_cls) RenameTablePartitionContext_cls = PyObject_GetAttrString(translator->parser_cls, "RenameTablePartitionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RenameTablePartitionContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRepairTable(fugue_sqlParser::RepairTableContext *ctx){
    if(!RepairTableContext_cls) RepairTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "RepairTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RepairTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRefreshResource(fugue_sqlParser::RefreshResourceContext *ctx){
    if(!RefreshResourceContext_cls) RefreshResourceContext_cls = PyObject_GetAttrString(translator->parser_cls, "RefreshResourceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RefreshResourceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowCreateTable(fugue_sqlParser::ShowCreateTableContext *ctx){
    if(!ShowCreateTableContext_cls) ShowCreateTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowCreateTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowCreateTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowNamespaces(fugue_sqlParser::ShowNamespacesContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"pattern", static_cast<void*>(ctx->pattern)}
    };
    if(!ShowNamespacesContext_cls) ShowNamespacesContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowNamespacesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowNamespacesContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowColumns(fugue_sqlParser::ShowColumnsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"table", static_cast<void*>(ctx->table)},
        {"ns", static_cast<void*>(ctx->ns)}
    };
    if(!ShowColumnsContext_cls) ShowColumnsContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowColumnsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowColumnsContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitReplaceTable(fugue_sqlParser::ReplaceTableContext *ctx){
    if(!ReplaceTableContext_cls) ReplaceTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "ReplaceTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ReplaceTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAddTablePartition(fugue_sqlParser::AddTablePartitionContext *ctx){
    if(!AddTablePartitionContext_cls) AddTablePartitionContext_cls = PyObject_GetAttrString(translator->parser_cls, "AddTablePartitionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AddTablePartitionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetNamespaceLocation(fugue_sqlParser::SetNamespaceLocationContext *ctx){
    if(!SetNamespaceLocationContext_cls) SetNamespaceLocationContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetNamespaceLocationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetNamespaceLocationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRefreshTable(fugue_sqlParser::RefreshTableContext *ctx){
    if(!RefreshTableContext_cls) RefreshTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "RefreshTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RefreshTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetNamespaceProperties(fugue_sqlParser::SetNamespacePropertiesContext *ctx){
    if(!SetNamespacePropertiesContext_cls) SetNamespacePropertiesContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetNamespacePropertiesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetNamespacePropertiesContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitManageResource(fugue_sqlParser::ManageResourceContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"op", static_cast<void*>(ctx->op)}
    };
    if(!ManageResourceContext_cls) ManageResourceContext_cls = PyObject_GetAttrString(translator->parser_cls, "ManageResourceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ManageResourceContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAnalyze(fugue_sqlParser::AnalyzeContext *ctx){
    if(!AnalyzeContext_cls) AnalyzeContext_cls = PyObject_GetAttrString(translator->parser_cls, "AnalyzeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AnalyzeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateHiveTable(fugue_sqlParser::CreateHiveTableContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"columns", static_cast<void*>(ctx->columns)},
        {"partitionColumns", static_cast<void*>(ctx->partitionColumns)},
        {"partitionColumnNames", static_cast<void*>(ctx->partitionColumnNames)},
        {"tableProps", static_cast<void*>(ctx->tableProps)}
    };
    if(!CreateHiveTableContext_cls) CreateHiveTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateHiveTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateHiveTableContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateFunction(fugue_sqlParser::CreateFunctionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"className", static_cast<void*>(ctx->className)}
    };
    if(!CreateFunctionContext_cls) CreateFunctionContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateFunctionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateFunctionContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowTable(fugue_sqlParser::ShowTableContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"ns", static_cast<void*>(ctx->ns)},
        {"pattern", static_cast<void*>(ctx->pattern)}
    };
    if(!ShowTableContext_cls) ShowTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowTableContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitHiveReplaceColumns(fugue_sqlParser::HiveReplaceColumnsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"table", static_cast<void*>(ctx->table)},
        {"columns", static_cast<void*>(ctx->columns)}
    };
    if(!HiveReplaceColumnsContext_cls) HiveReplaceColumnsContext_cls = PyObject_GetAttrString(translator->parser_cls, "HiveReplaceColumnsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, HiveReplaceColumnsContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCommentNamespace(fugue_sqlParser::CommentNamespaceContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"comment", static_cast<void*>(ctx->comment)}
    };
    if(!CommentNamespaceContext_cls) CommentNamespaceContext_cls = PyObject_GetAttrString(translator->parser_cls, "CommentNamespaceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CommentNamespaceContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateTable(fugue_sqlParser::CreateTableContext *ctx){
    if(!CreateTableContext_cls) CreateTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDmlStatement(fugue_sqlParser::DmlStatementContext *ctx){
    if(!DmlStatementContext_cls) DmlStatementContext_cls = PyObject_GetAttrString(translator->parser_cls, "DmlStatementContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DmlStatementContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateTableLike(fugue_sqlParser::CreateTableLikeContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"target", static_cast<void*>(ctx->target)},
        {"source", static_cast<void*>(ctx->source)},
        {"tableProps", static_cast<void*>(ctx->tableProps)}
    };
    if(!CreateTableLikeContext_cls) CreateTableLikeContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateTableLikeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateTableLikeContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitUncacheTable(fugue_sqlParser::UncacheTableContext *ctx){
    if(!UncacheTableContext_cls) UncacheTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "UncacheTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, UncacheTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDropFunction(fugue_sqlParser::DropFunctionContext *ctx){
    if(!DropFunctionContext_cls) DropFunctionContext_cls = PyObject_GetAttrString(translator->parser_cls, "DropFunctionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DropFunctionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDescribeRelation(fugue_sqlParser::DescribeRelationContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"option", static_cast<void*>(ctx->option)}
    };
    if(!DescribeRelationContext_cls) DescribeRelationContext_cls = PyObject_GetAttrString(translator->parser_cls, "DescribeRelationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DescribeRelationContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLoadData(fugue_sqlParser::LoadDataContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"path", static_cast<void*>(ctx->path)}
    };
    if(!LoadDataContext_cls) LoadDataContext_cls = PyObject_GetAttrString(translator->parser_cls, "LoadDataContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LoadDataContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowPartitions(fugue_sqlParser::ShowPartitionsContext *ctx){
    if(!ShowPartitionsContext_cls) ShowPartitionsContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowPartitionsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowPartitionsContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDescribeFunction(fugue_sqlParser::DescribeFunctionContext *ctx){
    if(!DescribeFunctionContext_cls) DescribeFunctionContext_cls = PyObject_GetAttrString(translator->parser_cls, "DescribeFunctionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DescribeFunctionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRenameTableColumn(fugue_sqlParser::RenameTableColumnContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"table", static_cast<void*>(ctx->table)},
        {"ifrom", static_cast<void*>(ctx->ifrom)},
        {"to", static_cast<void*>(ctx->to)}
    };
    if(!RenameTableColumnContext_cls) RenameTableColumnContext_cls = PyObject_GetAttrString(translator->parser_cls, "RenameTableColumnContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RenameTableColumnContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitStatementDefault(fugue_sqlParser::StatementDefaultContext *ctx){
    if(!StatementDefaultContext_cls) StatementDefaultContext_cls = PyObject_GetAttrString(translator->parser_cls, "StatementDefaultContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, StatementDefaultContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitHiveChangeColumn(fugue_sqlParser::HiveChangeColumnContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"table", static_cast<void*>(ctx->table)},
        {"colName", static_cast<void*>(ctx->colName)}
    };
    if(!HiveChangeColumnContext_cls) HiveChangeColumnContext_cls = PyObject_GetAttrString(translator->parser_cls, "HiveChangeColumnContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, HiveChangeColumnContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDescribeQuery(fugue_sqlParser::DescribeQueryContext *ctx){
    if(!DescribeQueryContext_cls) DescribeQueryContext_cls = PyObject_GetAttrString(translator->parser_cls, "DescribeQueryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DescribeQueryContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTruncateTable(fugue_sqlParser::TruncateTableContext *ctx){
    if(!TruncateTableContext_cls) TruncateTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "TruncateTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TruncateTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetTableSerDe(fugue_sqlParser::SetTableSerDeContext *ctx){
    if(!SetTableSerDeContext_cls) SetTableSerDeContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetTableSerDeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetTableSerDeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateView(fugue_sqlParser::CreateViewContext *ctx){
    if(!CreateViewContext_cls) CreateViewContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateViewContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateViewContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDropTablePartitions(fugue_sqlParser::DropTablePartitionsContext *ctx){
    if(!DropTablePartitionsContext_cls) DropTablePartitionsContext_cls = PyObject_GetAttrString(translator->parser_cls, "DropTablePartitionsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DropTablePartitionsContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetConfiguration(fugue_sqlParser::SetConfigurationContext *ctx){
    if(!SetConfigurationContext_cls) SetConfigurationContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetConfigurationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetConfigurationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDropTable(fugue_sqlParser::DropTableContext *ctx){
    if(!DropTableContext_cls) DropTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "DropTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DropTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDescribeNamespace(fugue_sqlParser::DescribeNamespaceContext *ctx){
    if(!DescribeNamespaceContext_cls) DescribeNamespaceContext_cls = PyObject_GetAttrString(translator->parser_cls, "DescribeNamespaceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DescribeNamespaceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAlterTableAlterColumn(fugue_sqlParser::AlterTableAlterColumnContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"table", static_cast<void*>(ctx->table)},
        {"column", static_cast<void*>(ctx->column)}
    };
    if(!AlterTableAlterColumnContext_cls) AlterTableAlterColumnContext_cls = PyObject_GetAttrString(translator->parser_cls, "AlterTableAlterColumnContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AlterTableAlterColumnContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCommentTable(fugue_sqlParser::CommentTableContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"comment", static_cast<void*>(ctx->comment)}
    };
    if(!CommentTableContext_cls) CommentTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "CommentTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CommentTableContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateNamespace(fugue_sqlParser::CreateNamespaceContext *ctx){
    if(!CreateNamespaceContext_cls) CreateNamespaceContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateNamespaceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateNamespaceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowTblProperties(fugue_sqlParser::ShowTblPropertiesContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"table", static_cast<void*>(ctx->table)},
        {"key", static_cast<void*>(ctx->key)}
    };
    if(!ShowTblPropertiesContext_cls) ShowTblPropertiesContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowTblPropertiesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowTblPropertiesContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitUnsetTableProperties(fugue_sqlParser::UnsetTablePropertiesContext *ctx){
    if(!UnsetTablePropertiesContext_cls) UnsetTablePropertiesContext_cls = PyObject_GetAttrString(translator->parser_cls, "UnsetTablePropertiesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, UnsetTablePropertiesContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetTableLocation(fugue_sqlParser::SetTableLocationContext *ctx){
    if(!SetTableLocationContext_cls) SetTableLocationContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetTableLocationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetTableLocationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDropTableColumns(fugue_sqlParser::DropTableColumnsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"columns", static_cast<void*>(ctx->columns)}
    };
    if(!DropTableColumnsContext_cls) DropTableColumnsContext_cls = PyObject_GetAttrString(translator->parser_cls, "DropTableColumnsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DropTableColumnsContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowViews(fugue_sqlParser::ShowViewsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"pattern", static_cast<void*>(ctx->pattern)}
    };
    if(!ShowViewsContext_cls) ShowViewsContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowViewsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowViewsContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitShowFunctions(fugue_sqlParser::ShowFunctionsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"pattern", static_cast<void*>(ctx->pattern)}
    };
    if(!ShowFunctionsContext_cls) ShowFunctionsContext_cls = PyObject_GetAttrString(translator->parser_cls, "ShowFunctionsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ShowFunctionsContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCacheTable(fugue_sqlParser::CacheTableContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"options", static_cast<void*>(ctx->options)}
    };
    if(!CacheTableContext_cls) CacheTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "CacheTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CacheTableContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAddTableColumns(fugue_sqlParser::AddTableColumnsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"columns", static_cast<void*>(ctx->columns)}
    };
    if(!AddTableColumnsContext_cls) AddTableColumnsContext_cls = PyObject_GetAttrString(translator->parser_cls, "AddTableColumnsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AddTableColumnsContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetTableProperties(fugue_sqlParser::SetTablePropertiesContext *ctx){
    if(!SetTablePropertiesContext_cls) SetTablePropertiesContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetTablePropertiesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetTablePropertiesContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitUnsupportedHiveNativeCommands(fugue_sqlParser::UnsupportedHiveNativeCommandsContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"kw1", static_cast<void*>(ctx->kw1)},
        {"kw2", static_cast<void*>(ctx->kw2)},
        {"kw3", static_cast<void*>(ctx->kw3)},
        {"kw4", static_cast<void*>(ctx->kw4)},
        {"kw5", static_cast<void*>(ctx->kw5)},
        {"kw6", static_cast<void*>(ctx->kw6)}
    };
    if(!UnsupportedHiveNativeCommandsContext_cls) UnsupportedHiveNativeCommandsContext_cls = PyObject_GetAttrString(translator->parser_cls, "UnsupportedHiveNativeCommandsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, UnsupportedHiveNativeCommandsContext_cls, labels, 6);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateTableHeader(fugue_sqlParser::CreateTableHeaderContext *ctx){
    if(!CreateTableHeaderContext_cls) CreateTableHeaderContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateTableHeaderContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateTableHeaderContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitReplaceTableHeader(fugue_sqlParser::ReplaceTableHeaderContext *ctx){
    if(!ReplaceTableHeaderContext_cls) ReplaceTableHeaderContext_cls = PyObject_GetAttrString(translator->parser_cls, "ReplaceTableHeaderContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ReplaceTableHeaderContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitBucketSpec(fugue_sqlParser::BucketSpecContext *ctx){
    if(!BucketSpecContext_cls) BucketSpecContext_cls = PyObject_GetAttrString(translator->parser_cls, "BucketSpecContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, BucketSpecContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSkewSpec(fugue_sqlParser::SkewSpecContext *ctx){
    if(!SkewSpecContext_cls) SkewSpecContext_cls = PyObject_GetAttrString(translator->parser_cls, "SkewSpecContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SkewSpecContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLocationSpec(fugue_sqlParser::LocationSpecContext *ctx){
    if(!LocationSpecContext_cls) LocationSpecContext_cls = PyObject_GetAttrString(translator->parser_cls, "LocationSpecContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LocationSpecContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCommentSpec(fugue_sqlParser::CommentSpecContext *ctx){
    if(!CommentSpecContext_cls) CommentSpecContext_cls = PyObject_GetAttrString(translator->parser_cls, "CommentSpecContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CommentSpecContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQuery(fugue_sqlParser::QueryContext *ctx){
    if(!QueryContext_cls) QueryContext_cls = PyObject_GetAttrString(translator->parser_cls, "QueryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QueryContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInsertOverwriteHiveDir(fugue_sqlParser::InsertOverwriteHiveDirContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"path", static_cast<void*>(ctx->path)}
    };
    if(!InsertOverwriteHiveDirContext_cls) InsertOverwriteHiveDirContext_cls = PyObject_GetAttrString(translator->parser_cls, "InsertOverwriteHiveDirContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, InsertOverwriteHiveDirContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInsertOverwriteDir(fugue_sqlParser::InsertOverwriteDirContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"path", static_cast<void*>(ctx->path)},
        {"options", static_cast<void*>(ctx->options)}
    };
    if(!InsertOverwriteDirContext_cls) InsertOverwriteDirContext_cls = PyObject_GetAttrString(translator->parser_cls, "InsertOverwriteDirContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, InsertOverwriteDirContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInsertOverwriteTable(fugue_sqlParser::InsertOverwriteTableContext *ctx){
    if(!InsertOverwriteTableContext_cls) InsertOverwriteTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "InsertOverwriteTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, InsertOverwriteTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInsertIntoTable(fugue_sqlParser::InsertIntoTableContext *ctx){
    if(!InsertIntoTableContext_cls) InsertIntoTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "InsertIntoTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, InsertIntoTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPartitionSpecLocation(fugue_sqlParser::PartitionSpecLocationContext *ctx){
    if(!PartitionSpecLocationContext_cls) PartitionSpecLocationContext_cls = PyObject_GetAttrString(translator->parser_cls, "PartitionSpecLocationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PartitionSpecLocationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPartitionSpec(fugue_sqlParser::PartitionSpecContext *ctx){
    if(!PartitionSpecContext_cls) PartitionSpecContext_cls = PyObject_GetAttrString(translator->parser_cls, "PartitionSpecContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PartitionSpecContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPartitionVal(fugue_sqlParser::PartitionValContext *ctx){
    if(!PartitionValContext_cls) PartitionValContext_cls = PyObject_GetAttrString(translator->parser_cls, "PartitionValContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PartitionValContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTheNamespace(fugue_sqlParser::TheNamespaceContext *ctx){
    if(!TheNamespaceContext_cls) TheNamespaceContext_cls = PyObject_GetAttrString(translator->parser_cls, "TheNamespaceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TheNamespaceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDescribeFuncName(fugue_sqlParser::DescribeFuncNameContext *ctx){
    if(!DescribeFuncNameContext_cls) DescribeFuncNameContext_cls = PyObject_GetAttrString(translator->parser_cls, "DescribeFuncNameContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DescribeFuncNameContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDescribeColName(fugue_sqlParser::DescribeColNameContext *ctx){
    if(!DescribeColNameContext_cls) DescribeColNameContext_cls = PyObject_GetAttrString(translator->parser_cls, "DescribeColNameContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DescribeColNameContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCtes(fugue_sqlParser::CtesContext *ctx){
    if(!CtesContext_cls) CtesContext_cls = PyObject_GetAttrString(translator->parser_cls, "CtesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CtesContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNamedQuery(fugue_sqlParser::NamedQueryContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)},
        {"columnAliases", static_cast<void*>(ctx->columnAliases)}
    };
    if(!NamedQueryContext_cls) NamedQueryContext_cls = PyObject_GetAttrString(translator->parser_cls, "NamedQueryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NamedQueryContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTableProvider(fugue_sqlParser::TableProviderContext *ctx){
    if(!TableProviderContext_cls) TableProviderContext_cls = PyObject_GetAttrString(translator->parser_cls, "TableProviderContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TableProviderContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateTableClauses(fugue_sqlParser::CreateTableClausesContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"options", static_cast<void*>(ctx->options)},
        {"partitioning", static_cast<void*>(ctx->partitioning)},
        {"tableProps", static_cast<void*>(ctx->tableProps)}
    };
    if(!CreateTableClausesContext_cls) CreateTableClausesContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateTableClausesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateTableClausesContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTablePropertyList(fugue_sqlParser::TablePropertyListContext *ctx){
    if(!TablePropertyListContext_cls) TablePropertyListContext_cls = PyObject_GetAttrString(translator->parser_cls, "TablePropertyListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TablePropertyListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTableProperty(fugue_sqlParser::TablePropertyContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"key", static_cast<void*>(ctx->key)},
        {"value", static_cast<void*>(ctx->value)}
    };
    if(!TablePropertyContext_cls) TablePropertyContext_cls = PyObject_GetAttrString(translator->parser_cls, "TablePropertyContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TablePropertyContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTablePropertyKey(fugue_sqlParser::TablePropertyKeyContext *ctx){
    if(!TablePropertyKeyContext_cls) TablePropertyKeyContext_cls = PyObject_GetAttrString(translator->parser_cls, "TablePropertyKeyContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TablePropertyKeyContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTablePropertyValue(fugue_sqlParser::TablePropertyValueContext *ctx){
    if(!TablePropertyValueContext_cls) TablePropertyValueContext_cls = PyObject_GetAttrString(translator->parser_cls, "TablePropertyValueContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TablePropertyValueContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitConstantList(fugue_sqlParser::ConstantListContext *ctx){
    if(!ConstantListContext_cls) ConstantListContext_cls = PyObject_GetAttrString(translator->parser_cls, "ConstantListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ConstantListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNestedConstantList(fugue_sqlParser::NestedConstantListContext *ctx){
    if(!NestedConstantListContext_cls) NestedConstantListContext_cls = PyObject_GetAttrString(translator->parser_cls, "NestedConstantListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NestedConstantListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCreateFileFormat(fugue_sqlParser::CreateFileFormatContext *ctx){
    if(!CreateFileFormatContext_cls) CreateFileFormatContext_cls = PyObject_GetAttrString(translator->parser_cls, "CreateFileFormatContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CreateFileFormatContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTableFileFormat(fugue_sqlParser::TableFileFormatContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"inFmt", static_cast<void*>(ctx->inFmt)},
        {"outFmt", static_cast<void*>(ctx->outFmt)}
    };
    if(!TableFileFormatContext_cls) TableFileFormatContext_cls = PyObject_GetAttrString(translator->parser_cls, "TableFileFormatContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TableFileFormatContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitGenericFileFormat(fugue_sqlParser::GenericFileFormatContext *ctx){
    if(!GenericFileFormatContext_cls) GenericFileFormatContext_cls = PyObject_GetAttrString(translator->parser_cls, "GenericFileFormatContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, GenericFileFormatContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitStorageHandler(fugue_sqlParser::StorageHandlerContext *ctx){
    if(!StorageHandlerContext_cls) StorageHandlerContext_cls = PyObject_GetAttrString(translator->parser_cls, "StorageHandlerContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, StorageHandlerContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitResource(fugue_sqlParser::ResourceContext *ctx){
    if(!ResourceContext_cls) ResourceContext_cls = PyObject_GetAttrString(translator->parser_cls, "ResourceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ResourceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDeleteFromTable(fugue_sqlParser::DeleteFromTableContext *ctx){
    if(!DeleteFromTableContext_cls) DeleteFromTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "DeleteFromTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DeleteFromTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSingleInsertQuery(fugue_sqlParser::SingleInsertQueryContext *ctx){
    if(!SingleInsertQueryContext_cls) SingleInsertQueryContext_cls = PyObject_GetAttrString(translator->parser_cls, "SingleInsertQueryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SingleInsertQueryContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMultiInsertQuery(fugue_sqlParser::MultiInsertQueryContext *ctx){
    if(!MultiInsertQueryContext_cls) MultiInsertQueryContext_cls = PyObject_GetAttrString(translator->parser_cls, "MultiInsertQueryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MultiInsertQueryContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitUpdateTable(fugue_sqlParser::UpdateTableContext *ctx){
    if(!UpdateTableContext_cls) UpdateTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "UpdateTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, UpdateTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMergeIntoTable(fugue_sqlParser::MergeIntoTableContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"target", static_cast<void*>(ctx->target)},
        {"targetAlias", static_cast<void*>(ctx->targetAlias)},
        {"source", static_cast<void*>(ctx->source)},
        {"sourceQuery", static_cast<void*>(ctx->sourceQuery)},
        {"sourceAlias", static_cast<void*>(ctx->sourceAlias)},
        {"mergeCondition", static_cast<void*>(ctx->mergeCondition)}
    };
    if(!MergeIntoTableContext_cls) MergeIntoTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "MergeIntoTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MergeIntoTableContext_cls, labels, 6);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQueryOrganization(fugue_sqlParser::QueryOrganizationContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"limit", static_cast<void*>(ctx->limit)}
    };
    if(!QueryOrganizationContext_cls) QueryOrganizationContext_cls = PyObject_GetAttrString(translator->parser_cls, "QueryOrganizationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QueryOrganizationContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMultiInsertQueryBody(fugue_sqlParser::MultiInsertQueryBodyContext *ctx){
    if(!MultiInsertQueryBodyContext_cls) MultiInsertQueryBodyContext_cls = PyObject_GetAttrString(translator->parser_cls, "MultiInsertQueryBodyContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MultiInsertQueryBodyContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQueryTermDefault(fugue_sqlParser::QueryTermDefaultContext *ctx){
    if(!QueryTermDefaultContext_cls) QueryTermDefaultContext_cls = PyObject_GetAttrString(translator->parser_cls, "QueryTermDefaultContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QueryTermDefaultContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFugueTerm(fugue_sqlParser::FugueTermContext *ctx){
    if(!FugueTermContext_cls) FugueTermContext_cls = PyObject_GetAttrString(translator->parser_cls, "FugueTermContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FugueTermContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetOperation(fugue_sqlParser::SetOperationContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"left", static_cast<void*>(ctx->left)},
        {"theOperator", static_cast<void*>(ctx->theOperator)},
        {"right", static_cast<void*>(ctx->right)}
    };
    if(!SetOperationContext_cls) SetOperationContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetOperationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetOperationContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQueryPrimaryDefault(fugue_sqlParser::QueryPrimaryDefaultContext *ctx){
    if(!QueryPrimaryDefaultContext_cls) QueryPrimaryDefaultContext_cls = PyObject_GetAttrString(translator->parser_cls, "QueryPrimaryDefaultContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QueryPrimaryDefaultContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInlineTableDefault1(fugue_sqlParser::InlineTableDefault1Context *ctx){
    if(!InlineTableDefault1Context_cls) InlineTableDefault1Context_cls = PyObject_GetAttrString(translator->parser_cls, "InlineTableDefault1Context");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, InlineTableDefault1Context_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFromStmt(fugue_sqlParser::FromStmtContext *ctx){
    if(!FromStmtContext_cls) FromStmtContext_cls = PyObject_GetAttrString(translator->parser_cls, "FromStmtContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FromStmtContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTable(fugue_sqlParser::TableContext *ctx){
    if(!TableContext_cls) TableContext_cls = PyObject_GetAttrString(translator->parser_cls, "TableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSortItem(fugue_sqlParser::SortItemContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"ordering", static_cast<void*>(ctx->ordering)},
        {"nullOrder", static_cast<void*>(ctx->nullOrder)}
    };
    if(!SortItemContext_cls) SortItemContext_cls = PyObject_GetAttrString(translator->parser_cls, "SortItemContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SortItemContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFromStatement(fugue_sqlParser::FromStatementContext *ctx){
    if(!FromStatementContext_cls) FromStatementContext_cls = PyObject_GetAttrString(translator->parser_cls, "FromStatementContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FromStatementContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFromStatementBody(fugue_sqlParser::FromStatementBodyContext *ctx){
    if(!FromStatementBodyContext_cls) FromStatementBodyContext_cls = PyObject_GetAttrString(translator->parser_cls, "FromStatementBodyContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FromStatementBodyContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRegularQuerySpecification(fugue_sqlParser::RegularQuerySpecificationContext *ctx){
    if(!RegularQuerySpecificationContext_cls) RegularQuerySpecificationContext_cls = PyObject_GetAttrString(translator->parser_cls, "RegularQuerySpecificationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RegularQuerySpecificationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTransformQuerySpecification(fugue_sqlParser::TransformQuerySpecificationContext *ctx){
    if(!TransformQuerySpecificationContext_cls) TransformQuerySpecificationContext_cls = PyObject_GetAttrString(translator->parser_cls, "TransformQuerySpecificationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TransformQuerySpecificationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitOptionalFromClause(fugue_sqlParser::OptionalFromClauseContext *ctx){
    if(!OptionalFromClauseContext_cls) OptionalFromClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "OptionalFromClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, OptionalFromClauseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTransformClause(fugue_sqlParser::TransformClauseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"kind", static_cast<void*>(ctx->kind)},
        {"inRowFormat", static_cast<void*>(ctx->inRowFormat)},
        {"recordWriter", static_cast<void*>(ctx->recordWriter)},
        {"script", static_cast<void*>(ctx->script)},
        {"outRowFormat", static_cast<void*>(ctx->outRowFormat)},
        {"recordReader", static_cast<void*>(ctx->recordReader)}
    };
    if(!TransformClauseContext_cls) TransformClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "TransformClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TransformClauseContext_cls, labels, 6);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSelectClause(fugue_sqlParser::SelectClauseContext *ctx){
    if(!SelectClauseContext_cls) SelectClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "SelectClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SelectClauseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetClause(fugue_sqlParser::SetClauseContext *ctx){
    if(!SetClauseContext_cls) SetClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetClauseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMatchedClause(fugue_sqlParser::MatchedClauseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"matchedCond", static_cast<void*>(ctx->matchedCond)}
    };
    if(!MatchedClauseContext_cls) MatchedClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "MatchedClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MatchedClauseContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNotMatchedClause(fugue_sqlParser::NotMatchedClauseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"notMatchedCond", static_cast<void*>(ctx->notMatchedCond)}
    };
    if(!NotMatchedClauseContext_cls) NotMatchedClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "NotMatchedClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NotMatchedClauseContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMatchedAction(fugue_sqlParser::MatchedActionContext *ctx){
    if(!MatchedActionContext_cls) MatchedActionContext_cls = PyObject_GetAttrString(translator->parser_cls, "MatchedActionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MatchedActionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNotMatchedAction(fugue_sqlParser::NotMatchedActionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"columns", static_cast<void*>(ctx->columns)}
    };
    if(!NotMatchedActionContext_cls) NotMatchedActionContext_cls = PyObject_GetAttrString(translator->parser_cls, "NotMatchedActionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NotMatchedActionContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAssignmentList(fugue_sqlParser::AssignmentListContext *ctx){
    if(!AssignmentListContext_cls) AssignmentListContext_cls = PyObject_GetAttrString(translator->parser_cls, "AssignmentListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AssignmentListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAssignment(fugue_sqlParser::AssignmentContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"key", static_cast<void*>(ctx->key)},
        {"value", static_cast<void*>(ctx->value)}
    };
    if(!AssignmentContext_cls) AssignmentContext_cls = PyObject_GetAttrString(translator->parser_cls, "AssignmentContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AssignmentContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitWhereClause(fugue_sqlParser::WhereClauseContext *ctx){
    if(!WhereClauseContext_cls) WhereClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "WhereClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, WhereClauseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitHavingClause(fugue_sqlParser::HavingClauseContext *ctx){
    if(!HavingClauseContext_cls) HavingClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "HavingClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, HavingClauseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitHint(fugue_sqlParser::HintContext *ctx){
    if(!HintContext_cls) HintContext_cls = PyObject_GetAttrString(translator->parser_cls, "HintContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, HintContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitHintStatement(fugue_sqlParser::HintStatementContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"hintName", static_cast<void*>(ctx->hintName)}
    };
    if(!HintStatementContext_cls) HintStatementContext_cls = PyObject_GetAttrString(translator->parser_cls, "HintStatementContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, HintStatementContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFromClause(fugue_sqlParser::FromClauseContext *ctx){
    if(!FromClauseContext_cls) FromClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "FromClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FromClauseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAggregationClause(fugue_sqlParser::AggregationClauseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"kind", static_cast<void*>(ctx->kind)}
    };
    if(!AggregationClauseContext_cls) AggregationClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "AggregationClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AggregationClauseContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitGroupingSet(fugue_sqlParser::GroupingSetContext *ctx){
    if(!GroupingSetContext_cls) GroupingSetContext_cls = PyObject_GetAttrString(translator->parser_cls, "GroupingSetContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, GroupingSetContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPivotClause(fugue_sqlParser::PivotClauseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"aggregates", static_cast<void*>(ctx->aggregates)}
    };
    if(!PivotClauseContext_cls) PivotClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "PivotClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PivotClauseContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPivotColumn(fugue_sqlParser::PivotColumnContext *ctx){
    if(!PivotColumnContext_cls) PivotColumnContext_cls = PyObject_GetAttrString(translator->parser_cls, "PivotColumnContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PivotColumnContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPivotValue(fugue_sqlParser::PivotValueContext *ctx){
    if(!PivotValueContext_cls) PivotValueContext_cls = PyObject_GetAttrString(translator->parser_cls, "PivotValueContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PivotValueContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLateralView(fugue_sqlParser::LateralViewContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"tblName", static_cast<void*>(ctx->tblName)}
    };
    if(!LateralViewContext_cls) LateralViewContext_cls = PyObject_GetAttrString(translator->parser_cls, "LateralViewContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LateralViewContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSetQuantifier(fugue_sqlParser::SetQuantifierContext *ctx){
    if(!SetQuantifierContext_cls) SetQuantifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "SetQuantifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SetQuantifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRelation(fugue_sqlParser::RelationContext *ctx){
    if(!RelationContext_cls) RelationContext_cls = PyObject_GetAttrString(translator->parser_cls, "RelationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RelationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitJoinRelation(fugue_sqlParser::JoinRelationContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"right", static_cast<void*>(ctx->right)}
    };
    if(!JoinRelationContext_cls) JoinRelationContext_cls = PyObject_GetAttrString(translator->parser_cls, "JoinRelationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, JoinRelationContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitJoinType(fugue_sqlParser::JoinTypeContext *ctx){
    if(!JoinTypeContext_cls) JoinTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "JoinTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, JoinTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitJoinCriteria(fugue_sqlParser::JoinCriteriaContext *ctx){
    if(!JoinCriteriaContext_cls) JoinCriteriaContext_cls = PyObject_GetAttrString(translator->parser_cls, "JoinCriteriaContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, JoinCriteriaContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSample(fugue_sqlParser::SampleContext *ctx){
    if(!SampleContext_cls) SampleContext_cls = PyObject_GetAttrString(translator->parser_cls, "SampleContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SampleContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSampleByRows(fugue_sqlParser::SampleByRowsContext *ctx){
    if(!SampleByRowsContext_cls) SampleByRowsContext_cls = PyObject_GetAttrString(translator->parser_cls, "SampleByRowsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SampleByRowsContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSampleByPercentile(fugue_sqlParser::SampleByPercentileContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"negativeSign", static_cast<void*>(ctx->negativeSign)},
        {"percentage", static_cast<void*>(ctx->percentage)}
    };
    if(!SampleByPercentileContext_cls) SampleByPercentileContext_cls = PyObject_GetAttrString(translator->parser_cls, "SampleByPercentileContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SampleByPercentileContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSampleByBucket(fugue_sqlParser::SampleByBucketContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"sampleType", static_cast<void*>(ctx->sampleType)},
        {"numerator", static_cast<void*>(ctx->numerator)},
        {"denominator", static_cast<void*>(ctx->denominator)}
    };
    if(!SampleByBucketContext_cls) SampleByBucketContext_cls = PyObject_GetAttrString(translator->parser_cls, "SampleByBucketContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SampleByBucketContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSampleByBytes(fugue_sqlParser::SampleByBytesContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"bytes", static_cast<void*>(ctx->bytes)}
    };
    if(!SampleByBytesContext_cls) SampleByBytesContext_cls = PyObject_GetAttrString(translator->parser_cls, "SampleByBytesContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SampleByBytesContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIdentifierList(fugue_sqlParser::IdentifierListContext *ctx){
    if(!IdentifierListContext_cls) IdentifierListContext_cls = PyObject_GetAttrString(translator->parser_cls, "IdentifierListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IdentifierListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIdentifierSeq(fugue_sqlParser::IdentifierSeqContext *ctx){
    if(!IdentifierSeqContext_cls) IdentifierSeqContext_cls = PyObject_GetAttrString(translator->parser_cls, "IdentifierSeqContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IdentifierSeqContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitOrderedIdentifierList(fugue_sqlParser::OrderedIdentifierListContext *ctx){
    if(!OrderedIdentifierListContext_cls) OrderedIdentifierListContext_cls = PyObject_GetAttrString(translator->parser_cls, "OrderedIdentifierListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, OrderedIdentifierListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitOrderedIdentifier(fugue_sqlParser::OrderedIdentifierContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"ident", static_cast<void*>(ctx->ident)},
        {"ordering", static_cast<void*>(ctx->ordering)}
    };
    if(!OrderedIdentifierContext_cls) OrderedIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "OrderedIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, OrderedIdentifierContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIdentifierCommentList(fugue_sqlParser::IdentifierCommentListContext *ctx){
    if(!IdentifierCommentListContext_cls) IdentifierCommentListContext_cls = PyObject_GetAttrString(translator->parser_cls, "IdentifierCommentListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IdentifierCommentListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIdentifierComment(fugue_sqlParser::IdentifierCommentContext *ctx){
    if(!IdentifierCommentContext_cls) IdentifierCommentContext_cls = PyObject_GetAttrString(translator->parser_cls, "IdentifierCommentContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IdentifierCommentContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTableValuedFunction(fugue_sqlParser::TableValuedFunctionContext *ctx){
    if(!TableValuedFunctionContext_cls) TableValuedFunctionContext_cls = PyObject_GetAttrString(translator->parser_cls, "TableValuedFunctionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TableValuedFunctionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInlineTableDefault2(fugue_sqlParser::InlineTableDefault2Context *ctx){
    if(!InlineTableDefault2Context_cls) InlineTableDefault2Context_cls = PyObject_GetAttrString(translator->parser_cls, "InlineTableDefault2Context");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, InlineTableDefault2Context_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAliasedRelation(fugue_sqlParser::AliasedRelationContext *ctx){
    if(!AliasedRelationContext_cls) AliasedRelationContext_cls = PyObject_GetAttrString(translator->parser_cls, "AliasedRelationContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AliasedRelationContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAliasedQuery(fugue_sqlParser::AliasedQueryContext *ctx){
    if(!AliasedQueryContext_cls) AliasedQueryContext_cls = PyObject_GetAttrString(translator->parser_cls, "AliasedQueryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AliasedQueryContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTableName(fugue_sqlParser::TableNameContext *ctx){
    if(!TableNameContext_cls) TableNameContext_cls = PyObject_GetAttrString(translator->parser_cls, "TableNameContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TableNameContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInlineTable(fugue_sqlParser::InlineTableContext *ctx){
    if(!InlineTableContext_cls) InlineTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "InlineTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, InlineTableContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFunctionTable(fugue_sqlParser::FunctionTableContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"funcName", static_cast<void*>(ctx->funcName)}
    };
    if(!FunctionTableContext_cls) FunctionTableContext_cls = PyObject_GetAttrString(translator->parser_cls, "FunctionTableContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FunctionTableContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTableAlias(fugue_sqlParser::TableAliasContext *ctx){
    if(!TableAliasContext_cls) TableAliasContext_cls = PyObject_GetAttrString(translator->parser_cls, "TableAliasContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TableAliasContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRowFormatSerde(fugue_sqlParser::RowFormatSerdeContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)},
        {"props", static_cast<void*>(ctx->props)}
    };
    if(!RowFormatSerdeContext_cls) RowFormatSerdeContext_cls = PyObject_GetAttrString(translator->parser_cls, "RowFormatSerdeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RowFormatSerdeContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRowFormatDelimited(fugue_sqlParser::RowFormatDelimitedContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"fieldsTerminatedBy", static_cast<void*>(ctx->fieldsTerminatedBy)},
        {"escapedBy", static_cast<void*>(ctx->escapedBy)},
        {"collectionItemsTerminatedBy", static_cast<void*>(ctx->collectionItemsTerminatedBy)},
        {"keysTerminatedBy", static_cast<void*>(ctx->keysTerminatedBy)},
        {"linesSeparatedBy", static_cast<void*>(ctx->linesSeparatedBy)},
        {"nullDefinedAs", static_cast<void*>(ctx->nullDefinedAs)}
    };
    if(!RowFormatDelimitedContext_cls) RowFormatDelimitedContext_cls = PyObject_GetAttrString(translator->parser_cls, "RowFormatDelimitedContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RowFormatDelimitedContext_cls, labels, 6);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMultipartIdentifierList(fugue_sqlParser::MultipartIdentifierListContext *ctx){
    if(!MultipartIdentifierListContext_cls) MultipartIdentifierListContext_cls = PyObject_GetAttrString(translator->parser_cls, "MultipartIdentifierListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MultipartIdentifierListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMultipartIdentifier(fugue_sqlParser::MultipartIdentifierContext *ctx){
    if(!MultipartIdentifierContext_cls) MultipartIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "MultipartIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MultipartIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTableIdentifier(fugue_sqlParser::TableIdentifierContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"db", static_cast<void*>(ctx->db)},
        {"table", static_cast<void*>(ctx->table)}
    };
    if(!TableIdentifierContext_cls) TableIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "TableIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TableIdentifierContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFunctionIdentifier(fugue_sqlParser::FunctionIdentifierContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"db", static_cast<void*>(ctx->db)},
        {"function", static_cast<void*>(ctx->function)}
    };
    if(!FunctionIdentifierContext_cls) FunctionIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "FunctionIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FunctionIdentifierContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNamedExpression(fugue_sqlParser::NamedExpressionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)}
    };
    if(!NamedExpressionContext_cls) NamedExpressionContext_cls = PyObject_GetAttrString(translator->parser_cls, "NamedExpressionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NamedExpressionContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNamedExpressionSeq(fugue_sqlParser::NamedExpressionSeqContext *ctx){
    if(!NamedExpressionSeqContext_cls) NamedExpressionSeqContext_cls = PyObject_GetAttrString(translator->parser_cls, "NamedExpressionSeqContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NamedExpressionSeqContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTransformList(fugue_sqlParser::TransformListContext *ctx){
    if(!TransformListContext_cls) TransformListContext_cls = PyObject_GetAttrString(translator->parser_cls, "TransformListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TransformListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIdentityTransform(fugue_sqlParser::IdentityTransformContext *ctx){
    if(!IdentityTransformContext_cls) IdentityTransformContext_cls = PyObject_GetAttrString(translator->parser_cls, "IdentityTransformContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IdentityTransformContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitApplyTransform(fugue_sqlParser::ApplyTransformContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"transformName", static_cast<void*>(ctx->transformName)}
    };
    if(!ApplyTransformContext_cls) ApplyTransformContext_cls = PyObject_GetAttrString(translator->parser_cls, "ApplyTransformContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ApplyTransformContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTransformArgument(fugue_sqlParser::TransformArgumentContext *ctx){
    if(!TransformArgumentContext_cls) TransformArgumentContext_cls = PyObject_GetAttrString(translator->parser_cls, "TransformArgumentContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TransformArgumentContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitExpression(fugue_sqlParser::ExpressionContext *ctx){
    if(!ExpressionContext_cls) ExpressionContext_cls = PyObject_GetAttrString(translator->parser_cls, "ExpressionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ExpressionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLogicalNot(fugue_sqlParser::LogicalNotContext *ctx){
    if(!LogicalNotContext_cls) LogicalNotContext_cls = PyObject_GetAttrString(translator->parser_cls, "LogicalNotContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LogicalNotContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPredicated(fugue_sqlParser::PredicatedContext *ctx){
    if(!PredicatedContext_cls) PredicatedContext_cls = PyObject_GetAttrString(translator->parser_cls, "PredicatedContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PredicatedContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitExists(fugue_sqlParser::ExistsContext *ctx){
    if(!ExistsContext_cls) ExistsContext_cls = PyObject_GetAttrString(translator->parser_cls, "ExistsContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ExistsContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLogicalBinary(fugue_sqlParser::LogicalBinaryContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"left", static_cast<void*>(ctx->left)},
        {"theOperator", static_cast<void*>(ctx->theOperator)},
        {"right", static_cast<void*>(ctx->right)}
    };
    if(!LogicalBinaryContext_cls) LogicalBinaryContext_cls = PyObject_GetAttrString(translator->parser_cls, "LogicalBinaryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LogicalBinaryContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPredicate(fugue_sqlParser::PredicateContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"kind", static_cast<void*>(ctx->kind)},
        {"lower", static_cast<void*>(ctx->lower)},
        {"upper", static_cast<void*>(ctx->upper)},
        {"pattern", static_cast<void*>(ctx->pattern)},
        {"quantifier", static_cast<void*>(ctx->quantifier)},
        {"escapeChar", static_cast<void*>(ctx->escapeChar)},
        {"right", static_cast<void*>(ctx->right)}
    };
    if(!PredicateContext_cls) PredicateContext_cls = PyObject_GetAttrString(translator->parser_cls, "PredicateContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PredicateContext_cls, labels, 7);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitValueExpressionDefault(fugue_sqlParser::ValueExpressionDefaultContext *ctx){
    if(!ValueExpressionDefaultContext_cls) ValueExpressionDefaultContext_cls = PyObject_GetAttrString(translator->parser_cls, "ValueExpressionDefaultContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ValueExpressionDefaultContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitComparison(fugue_sqlParser::ComparisonContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"left", static_cast<void*>(ctx->left)},
        {"right", static_cast<void*>(ctx->right)}
    };
    if(!ComparisonContext_cls) ComparisonContext_cls = PyObject_GetAttrString(translator->parser_cls, "ComparisonContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ComparisonContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitArithmeticBinary(fugue_sqlParser::ArithmeticBinaryContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"left", static_cast<void*>(ctx->left)},
        {"theOperator", static_cast<void*>(ctx->theOperator)},
        {"right", static_cast<void*>(ctx->right)}
    };
    if(!ArithmeticBinaryContext_cls) ArithmeticBinaryContext_cls = PyObject_GetAttrString(translator->parser_cls, "ArithmeticBinaryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ArithmeticBinaryContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitArithmeticUnary(fugue_sqlParser::ArithmeticUnaryContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"theOperator", static_cast<void*>(ctx->theOperator)}
    };
    if(!ArithmeticUnaryContext_cls) ArithmeticUnaryContext_cls = PyObject_GetAttrString(translator->parser_cls, "ArithmeticUnaryContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ArithmeticUnaryContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitStruct(fugue_sqlParser::StructContext *ctx){
    if(!StructContext_cls) StructContext_cls = PyObject_GetAttrString(translator->parser_cls, "StructContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, StructContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDereference(fugue_sqlParser::DereferenceContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"base", static_cast<void*>(ctx->base)},
        {"fieldName", static_cast<void*>(ctx->fieldName)}
    };
    if(!DereferenceContext_cls) DereferenceContext_cls = PyObject_GetAttrString(translator->parser_cls, "DereferenceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DereferenceContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSimpleCase(fugue_sqlParser::SimpleCaseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"value", static_cast<void*>(ctx->value)},
        {"elseExpression", static_cast<void*>(ctx->elseExpression)}
    };
    if(!SimpleCaseContext_cls) SimpleCaseContext_cls = PyObject_GetAttrString(translator->parser_cls, "SimpleCaseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SimpleCaseContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitColumnReference(fugue_sqlParser::ColumnReferenceContext *ctx){
    if(!ColumnReferenceContext_cls) ColumnReferenceContext_cls = PyObject_GetAttrString(translator->parser_cls, "ColumnReferenceContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ColumnReferenceContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitRowConstructor(fugue_sqlParser::RowConstructorContext *ctx){
    if(!RowConstructorContext_cls) RowConstructorContext_cls = PyObject_GetAttrString(translator->parser_cls, "RowConstructorContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, RowConstructorContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLast(fugue_sqlParser::LastContext *ctx){
    if(!LastContext_cls) LastContext_cls = PyObject_GetAttrString(translator->parser_cls, "LastContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LastContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitStar(fugue_sqlParser::StarContext *ctx){
    if(!StarContext_cls) StarContext_cls = PyObject_GetAttrString(translator->parser_cls, "StarContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, StarContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitOverlay(fugue_sqlParser::OverlayContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"iinput", static_cast<void*>(ctx->iinput)},
        {"replace", static_cast<void*>(ctx->replace)},
        {"position", static_cast<void*>(ctx->position)},
        {"length", static_cast<void*>(ctx->length)}
    };
    if(!OverlayContext_cls) OverlayContext_cls = PyObject_GetAttrString(translator->parser_cls, "OverlayContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, OverlayContext_cls, labels, 4);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSubscript(fugue_sqlParser::SubscriptContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"value", static_cast<void*>(ctx->value)},
        {"index", static_cast<void*>(ctx->index)}
    };
    if(!SubscriptContext_cls) SubscriptContext_cls = PyObject_GetAttrString(translator->parser_cls, "SubscriptContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SubscriptContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSubqueryExpression(fugue_sqlParser::SubqueryExpressionContext *ctx){
    if(!SubqueryExpressionContext_cls) SubqueryExpressionContext_cls = PyObject_GetAttrString(translator->parser_cls, "SubqueryExpressionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SubqueryExpressionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSubstring(fugue_sqlParser::SubstringContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"istr", static_cast<void*>(ctx->istr)},
        {"pos", static_cast<void*>(ctx->pos)},
        {"ilen", static_cast<void*>(ctx->ilen)}
    };
    if(!SubstringContext_cls) SubstringContext_cls = PyObject_GetAttrString(translator->parser_cls, "SubstringContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SubstringContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCurrentDatetime(fugue_sqlParser::CurrentDatetimeContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)}
    };
    if(!CurrentDatetimeContext_cls) CurrentDatetimeContext_cls = PyObject_GetAttrString(translator->parser_cls, "CurrentDatetimeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CurrentDatetimeContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitCast(fugue_sqlParser::CastContext *ctx){
    if(!CastContext_cls) CastContext_cls = PyObject_GetAttrString(translator->parser_cls, "CastContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, CastContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitConstantDefault(fugue_sqlParser::ConstantDefaultContext *ctx){
    if(!ConstantDefaultContext_cls) ConstantDefaultContext_cls = PyObject_GetAttrString(translator->parser_cls, "ConstantDefaultContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ConstantDefaultContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLambda(fugue_sqlParser::LambdaContext *ctx){
    if(!LambdaContext_cls) LambdaContext_cls = PyObject_GetAttrString(translator->parser_cls, "LambdaContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LambdaContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitParenthesizedExpression(fugue_sqlParser::ParenthesizedExpressionContext *ctx){
    if(!ParenthesizedExpressionContext_cls) ParenthesizedExpressionContext_cls = PyObject_GetAttrString(translator->parser_cls, "ParenthesizedExpressionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ParenthesizedExpressionContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitExtract(fugue_sqlParser::ExtractContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"field", static_cast<void*>(ctx->field)},
        {"source", static_cast<void*>(ctx->source)}
    };
    if(!ExtractContext_cls) ExtractContext_cls = PyObject_GetAttrString(translator->parser_cls, "ExtractContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ExtractContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTrim(fugue_sqlParser::TrimContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"trimOption", static_cast<void*>(ctx->trimOption)},
        {"trimStr", static_cast<void*>(ctx->trimStr)},
        {"srcStr", static_cast<void*>(ctx->srcStr)}
    };
    if(!TrimContext_cls) TrimContext_cls = PyObject_GetAttrString(translator->parser_cls, "TrimContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TrimContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFunctionCall(fugue_sqlParser::FunctionCallContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"where", static_cast<void*>(ctx->where)}
    };
    if(!FunctionCallContext_cls) FunctionCallContext_cls = PyObject_GetAttrString(translator->parser_cls, "FunctionCallContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FunctionCallContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSearchedCase(fugue_sqlParser::SearchedCaseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"elseExpression", static_cast<void*>(ctx->elseExpression)}
    };
    if(!SearchedCaseContext_cls) SearchedCaseContext_cls = PyObject_GetAttrString(translator->parser_cls, "SearchedCaseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SearchedCaseContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPosition(fugue_sqlParser::PositionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"substr", static_cast<void*>(ctx->substr)},
        {"istr", static_cast<void*>(ctx->istr)}
    };
    if(!PositionContext_cls) PositionContext_cls = PyObject_GetAttrString(translator->parser_cls, "PositionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PositionContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFirst(fugue_sqlParser::FirstContext *ctx){
    if(!FirstContext_cls) FirstContext_cls = PyObject_GetAttrString(translator->parser_cls, "FirstContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FirstContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNullLiteral(fugue_sqlParser::NullLiteralContext *ctx){
    if(!NullLiteralContext_cls) NullLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "NullLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NullLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitStringLiteral(fugue_sqlParser::StringLiteralContext *ctx){
    if(!StringLiteralContext_cls) StringLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "StringLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, StringLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTypeConstructor(fugue_sqlParser::TypeConstructorContext *ctx){
    if(!TypeConstructorContext_cls) TypeConstructorContext_cls = PyObject_GetAttrString(translator->parser_cls, "TypeConstructorContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TypeConstructorContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIntervalLiteral(fugue_sqlParser::IntervalLiteralContext *ctx){
    if(!IntervalLiteralContext_cls) IntervalLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "IntervalLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IntervalLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNumericLiteral(fugue_sqlParser::NumericLiteralContext *ctx){
    if(!NumericLiteralContext_cls) NumericLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "NumericLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NumericLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitBooleanLiteral(fugue_sqlParser::BooleanLiteralContext *ctx){
    if(!BooleanLiteralContext_cls) BooleanLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "BooleanLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, BooleanLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitComparisonOperator(fugue_sqlParser::ComparisonOperatorContext *ctx){
    if(!ComparisonOperatorContext_cls) ComparisonOperatorContext_cls = PyObject_GetAttrString(translator->parser_cls, "ComparisonOperatorContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ComparisonOperatorContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitComparisonEqualOperator(fugue_sqlParser::ComparisonEqualOperatorContext *ctx){
    if(!ComparisonEqualOperatorContext_cls) ComparisonEqualOperatorContext_cls = PyObject_GetAttrString(translator->parser_cls, "ComparisonEqualOperatorContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ComparisonEqualOperatorContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitArithmeticOperator(fugue_sqlParser::ArithmeticOperatorContext *ctx){
    if(!ArithmeticOperatorContext_cls) ArithmeticOperatorContext_cls = PyObject_GetAttrString(translator->parser_cls, "ArithmeticOperatorContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ArithmeticOperatorContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPredicateOperator(fugue_sqlParser::PredicateOperatorContext *ctx){
    if(!PredicateOperatorContext_cls) PredicateOperatorContext_cls = PyObject_GetAttrString(translator->parser_cls, "PredicateOperatorContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PredicateOperatorContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitBooleanValue(fugue_sqlParser::BooleanValueContext *ctx){
    if(!BooleanValueContext_cls) BooleanValueContext_cls = PyObject_GetAttrString(translator->parser_cls, "BooleanValueContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, BooleanValueContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitInterval(fugue_sqlParser::IntervalContext *ctx){
    if(!IntervalContext_cls) IntervalContext_cls = PyObject_GetAttrString(translator->parser_cls, "IntervalContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IntervalContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitErrorCapturingMultiUnitsInterval(fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext *ctx){
    if(!ErrorCapturingMultiUnitsIntervalContext_cls) ErrorCapturingMultiUnitsIntervalContext_cls = PyObject_GetAttrString(translator->parser_cls, "ErrorCapturingMultiUnitsIntervalContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ErrorCapturingMultiUnitsIntervalContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitMultiUnitsInterval(fugue_sqlParser::MultiUnitsIntervalContext *ctx){
    if(!MultiUnitsIntervalContext_cls) MultiUnitsIntervalContext_cls = PyObject_GetAttrString(translator->parser_cls, "MultiUnitsIntervalContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, MultiUnitsIntervalContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitErrorCapturingUnitToUnitInterval(fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"body", static_cast<void*>(ctx->body)},
        {"error1", static_cast<void*>(ctx->error1)},
        {"error2", static_cast<void*>(ctx->error2)}
    };
    if(!ErrorCapturingUnitToUnitIntervalContext_cls) ErrorCapturingUnitToUnitIntervalContext_cls = PyObject_GetAttrString(translator->parser_cls, "ErrorCapturingUnitToUnitIntervalContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ErrorCapturingUnitToUnitIntervalContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitUnitToUnitInterval(fugue_sqlParser::UnitToUnitIntervalContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"value", static_cast<void*>(ctx->value)},
        {"ifrom", static_cast<void*>(ctx->ifrom)},
        {"to", static_cast<void*>(ctx->to)}
    };
    if(!UnitToUnitIntervalContext_cls) UnitToUnitIntervalContext_cls = PyObject_GetAttrString(translator->parser_cls, "UnitToUnitIntervalContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, UnitToUnitIntervalContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIntervalValue(fugue_sqlParser::IntervalValueContext *ctx){
    if(!IntervalValueContext_cls) IntervalValueContext_cls = PyObject_GetAttrString(translator->parser_cls, "IntervalValueContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IntervalValueContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIntervalUnit(fugue_sqlParser::IntervalUnitContext *ctx){
    if(!IntervalUnitContext_cls) IntervalUnitContext_cls = PyObject_GetAttrString(translator->parser_cls, "IntervalUnitContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IntervalUnitContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitColPosition(fugue_sqlParser::ColPositionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"position", static_cast<void*>(ctx->position)},
        {"afterCol", static_cast<void*>(ctx->afterCol)}
    };
    if(!ColPositionContext_cls) ColPositionContext_cls = PyObject_GetAttrString(translator->parser_cls, "ColPositionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ColPositionContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitComplexDataType(fugue_sqlParser::ComplexDataTypeContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"icomplex", static_cast<void*>(ctx->icomplex)}
    };
    if(!ComplexDataTypeContext_cls) ComplexDataTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "ComplexDataTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ComplexDataTypeContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitPrimitiveDataType(fugue_sqlParser::PrimitiveDataTypeContext *ctx){
    if(!PrimitiveDataTypeContext_cls) PrimitiveDataTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "PrimitiveDataTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, PrimitiveDataTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQualifiedColTypeWithPositionList(fugue_sqlParser::QualifiedColTypeWithPositionListContext *ctx){
    if(!QualifiedColTypeWithPositionListContext_cls) QualifiedColTypeWithPositionListContext_cls = PyObject_GetAttrString(translator->parser_cls, "QualifiedColTypeWithPositionListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QualifiedColTypeWithPositionListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQualifiedColTypeWithPosition(fugue_sqlParser::QualifiedColTypeWithPositionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)}
    };
    if(!QualifiedColTypeWithPositionContext_cls) QualifiedColTypeWithPositionContext_cls = PyObject_GetAttrString(translator->parser_cls, "QualifiedColTypeWithPositionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QualifiedColTypeWithPositionContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitColTypeList(fugue_sqlParser::ColTypeListContext *ctx){
    if(!ColTypeListContext_cls) ColTypeListContext_cls = PyObject_GetAttrString(translator->parser_cls, "ColTypeListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ColTypeListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitColType(fugue_sqlParser::ColTypeContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"colName", static_cast<void*>(ctx->colName)}
    };
    if(!ColTypeContext_cls) ColTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "ColTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ColTypeContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitComplexColTypeList(fugue_sqlParser::ComplexColTypeListContext *ctx){
    if(!ComplexColTypeListContext_cls) ComplexColTypeListContext_cls = PyObject_GetAttrString(translator->parser_cls, "ComplexColTypeListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ComplexColTypeListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitComplexColType(fugue_sqlParser::ComplexColTypeContext *ctx){
    if(!ComplexColTypeContext_cls) ComplexColTypeContext_cls = PyObject_GetAttrString(translator->parser_cls, "ComplexColTypeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ComplexColTypeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitWhenClause(fugue_sqlParser::WhenClauseContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"condition", static_cast<void*>(ctx->condition)},
        {"result", static_cast<void*>(ctx->result)}
    };
    if(!WhenClauseContext_cls) WhenClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "WhenClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, WhenClauseContext_cls, labels, 2);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitWindowClause(fugue_sqlParser::WindowClauseContext *ctx){
    if(!WindowClauseContext_cls) WindowClauseContext_cls = PyObject_GetAttrString(translator->parser_cls, "WindowClauseContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, WindowClauseContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNamedWindow(fugue_sqlParser::NamedWindowContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)}
    };
    if(!NamedWindowContext_cls) NamedWindowContext_cls = PyObject_GetAttrString(translator->parser_cls, "NamedWindowContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NamedWindowContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitWindowRef(fugue_sqlParser::WindowRefContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"name", static_cast<void*>(ctx->name)}
    };
    if(!WindowRefContext_cls) WindowRefContext_cls = PyObject_GetAttrString(translator->parser_cls, "WindowRefContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, WindowRefContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitWindowDef(fugue_sqlParser::WindowDefContext *ctx){
    if(!WindowDefContext_cls) WindowDefContext_cls = PyObject_GetAttrString(translator->parser_cls, "WindowDefContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, WindowDefContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitWindowFrame(fugue_sqlParser::WindowFrameContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"frameType", static_cast<void*>(ctx->frameType)},
        {"start", static_cast<void*>(ctx->start)},
        {"end", static_cast<void*>(ctx->end)}
    };
    if(!WindowFrameContext_cls) WindowFrameContext_cls = PyObject_GetAttrString(translator->parser_cls, "WindowFrameContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, WindowFrameContext_cls, labels, 3);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFrameBound(fugue_sqlParser::FrameBoundContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"boundType", static_cast<void*>(ctx->boundType)}
    };
    if(!FrameBoundContext_cls) FrameBoundContext_cls = PyObject_GetAttrString(translator->parser_cls, "FrameBoundContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FrameBoundContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQualifiedNameList(fugue_sqlParser::QualifiedNameListContext *ctx){
    if(!QualifiedNameListContext_cls) QualifiedNameListContext_cls = PyObject_GetAttrString(translator->parser_cls, "QualifiedNameListContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QualifiedNameListContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitFunctionName(fugue_sqlParser::FunctionNameContext *ctx){
    if(!FunctionNameContext_cls) FunctionNameContext_cls = PyObject_GetAttrString(translator->parser_cls, "FunctionNameContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, FunctionNameContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQualifiedName(fugue_sqlParser::QualifiedNameContext *ctx){
    if(!QualifiedNameContext_cls) QualifiedNameContext_cls = PyObject_GetAttrString(translator->parser_cls, "QualifiedNameContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QualifiedNameContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitErrorCapturingIdentifier(fugue_sqlParser::ErrorCapturingIdentifierContext *ctx){
    if(!ErrorCapturingIdentifierContext_cls) ErrorCapturingIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "ErrorCapturingIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ErrorCapturingIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitErrorIdent(fugue_sqlParser::ErrorIdentContext *ctx){
    if(!ErrorIdentContext_cls) ErrorIdentContext_cls = PyObject_GetAttrString(translator->parser_cls, "ErrorIdentContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ErrorIdentContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIdentifier(fugue_sqlParser::IdentifierContext *ctx){
    if(!IdentifierContext_cls) IdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "IdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQuotedIdentifierAlternative(fugue_sqlParser::QuotedIdentifierAlternativeContext *ctx){
    if(!QuotedIdentifierAlternativeContext_cls) QuotedIdentifierAlternativeContext_cls = PyObject_GetAttrString(translator->parser_cls, "QuotedIdentifierAlternativeContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QuotedIdentifierAlternativeContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitUnquotedIdentifier(fugue_sqlParser::UnquotedIdentifierContext *ctx){
    if(!UnquotedIdentifierContext_cls) UnquotedIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "UnquotedIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, UnquotedIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitQuotedIdentifier(fugue_sqlParser::QuotedIdentifierContext *ctx){
    if(!QuotedIdentifierContext_cls) QuotedIdentifierContext_cls = PyObject_GetAttrString(translator->parser_cls, "QuotedIdentifierContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, QuotedIdentifierContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDecimalLiteral(fugue_sqlParser::DecimalLiteralContext *ctx){
    if(!DecimalLiteralContext_cls) DecimalLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "DecimalLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DecimalLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitBigIntLiteral(fugue_sqlParser::BigIntLiteralContext *ctx){
    if(!BigIntLiteralContext_cls) BigIntLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "BigIntLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, BigIntLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitTinyIntLiteral(fugue_sqlParser::TinyIntLiteralContext *ctx){
    if(!TinyIntLiteralContext_cls) TinyIntLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "TinyIntLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, TinyIntLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitLegacyDecimalLiteral(fugue_sqlParser::LegacyDecimalLiteralContext *ctx){
    if(!LegacyDecimalLiteralContext_cls) LegacyDecimalLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "LegacyDecimalLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, LegacyDecimalLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitBigDecimalLiteral(fugue_sqlParser::BigDecimalLiteralContext *ctx){
    if(!BigDecimalLiteralContext_cls) BigDecimalLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "BigDecimalLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, BigDecimalLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitExponentLiteral(fugue_sqlParser::ExponentLiteralContext *ctx){
    if(!ExponentLiteralContext_cls) ExponentLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "ExponentLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, ExponentLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitDoubleLiteral(fugue_sqlParser::DoubleLiteralContext *ctx){
    if(!DoubleLiteralContext_cls) DoubleLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "DoubleLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, DoubleLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitIntegerLiteral(fugue_sqlParser::IntegerLiteralContext *ctx){
    if(!IntegerLiteralContext_cls) IntegerLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "IntegerLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, IntegerLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitSmallIntLiteral(fugue_sqlParser::SmallIntLiteralContext *ctx){
    if(!SmallIntLiteralContext_cls) SmallIntLiteralContext_cls = PyObject_GetAttrString(translator->parser_cls, "SmallIntLiteralContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, SmallIntLiteralContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAlterColumnAction(fugue_sqlParser::AlterColumnActionContext *ctx){
    speedy_antlr::LabelMap labels[] = {
        {"setOrDrop", static_cast<void*>(ctx->setOrDrop)}
    };
    if(!AlterColumnActionContext_cls) AlterColumnActionContext_cls = PyObject_GetAttrString(translator->parser_cls, "AlterColumnActionContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AlterColumnActionContext_cls, labels, 1);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitAnsiNonReserved(fugue_sqlParser::AnsiNonReservedContext *ctx){
    if(!AnsiNonReservedContext_cls) AnsiNonReservedContext_cls = PyObject_GetAttrString(translator->parser_cls, "AnsiNonReservedContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, AnsiNonReservedContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitStrictNonReserved(fugue_sqlParser::StrictNonReservedContext *ctx){
    if(!StrictNonReservedContext_cls) StrictNonReservedContext_cls = PyObject_GetAttrString(translator->parser_cls, "StrictNonReservedContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, StrictNonReservedContext_cls);
    return py_ctx;
}

antlrcpp::Any SA_fugue_sqlTranslator::visitNonReserved(fugue_sqlParser::NonReservedContext *ctx){
    if(!NonReservedContext_cls) NonReservedContext_cls = PyObject_GetAttrString(translator->parser_cls, "NonReservedContext");
    PyObject *py_ctx = translator->convert_ctx(this, ctx, NonReservedContext_cls);
    return py_ctx;
}
