# Code generated by protox. Don't edit. # credo:disable-for-this-file defmodule PgQuery.Node do @moduledoc false if function_exported?(Protox, :check_generator_version, 1) do Protox.check_generator_version(1) else raise "This code was generated with protox 2 but the runtime is using an older version of protox." end @type t :: %__MODULE__{ node: {:alias, PgQuery.Alias.t()} | {:range_var, PgQuery.RangeVar.t()} | {:table_func, PgQuery.TableFunc.t()} | {:into_clause, PgQuery.IntoClause.t()} | {:var, PgQuery.Var.t()} | {:param, PgQuery.Param.t()} | {:aggref, PgQuery.Aggref.t()} | {:grouping_func, PgQuery.GroupingFunc.t()} | {:window_func, PgQuery.WindowFunc.t()} | {:window_func_run_condition, PgQuery.WindowFuncRunCondition.t()} | {:merge_support_func, PgQuery.MergeSupportFunc.t()} | {:subscripting_ref, PgQuery.SubscriptingRef.t()} | {:func_expr, PgQuery.FuncExpr.t()} | {:named_arg_expr, PgQuery.NamedArgExpr.t()} | {:op_expr, PgQuery.OpExpr.t()} | {:distinct_expr, PgQuery.DistinctExpr.t()} | {:null_if_expr, PgQuery.NullIfExpr.t()} | {:scalar_array_op_expr, PgQuery.ScalarArrayOpExpr.t()} | {:bool_expr, PgQuery.BoolExpr.t()} | {:sub_link, PgQuery.SubLink.t()} | {:sub_plan, PgQuery.SubPlan.t()} | {:alternative_sub_plan, PgQuery.AlternativeSubPlan.t()} | {:field_select, PgQuery.FieldSelect.t()} | {:field_store, PgQuery.FieldStore.t()} | {:relabel_type, PgQuery.RelabelType.t()} | {:coerce_via_io, PgQuery.CoerceViaIO.t()} | {:array_coerce_expr, PgQuery.ArrayCoerceExpr.t()} | {:convert_rowtype_expr, PgQuery.ConvertRowtypeExpr.t()} | {:collate_expr, PgQuery.CollateExpr.t()} | {:case_expr, PgQuery.CaseExpr.t()} | {:case_when, PgQuery.CaseWhen.t()} | {:case_test_expr, PgQuery.CaseTestExpr.t()} | {:array_expr, PgQuery.ArrayExpr.t()} | {:row_expr, PgQuery.RowExpr.t()} | {:row_compare_expr, PgQuery.RowCompareExpr.t()} | {:coalesce_expr, PgQuery.CoalesceExpr.t()} | {:min_max_expr, PgQuery.MinMaxExpr.t()} | {:sqlvalue_function, PgQuery.SQLValueFunction.t()} | {:xml_expr, PgQuery.XmlExpr.t()} | {:json_format, PgQuery.JsonFormat.t()} | {:json_returning, PgQuery.JsonReturning.t()} | {:json_value_expr, PgQuery.JsonValueExpr.t()} | {:json_constructor_expr, PgQuery.JsonConstructorExpr.t()} | {:json_is_predicate, PgQuery.JsonIsPredicate.t()} | {:json_behavior, PgQuery.JsonBehavior.t()} | {:json_expr, PgQuery.JsonExpr.t()} | {:json_table_path, PgQuery.JsonTablePath.t()} | {:json_table_path_scan, PgQuery.JsonTablePathScan.t()} | {:json_table_sibling_join, PgQuery.JsonTableSiblingJoin.t()} | {:null_test, PgQuery.NullTest.t()} | {:boolean_test, PgQuery.BooleanTest.t()} | {:merge_action, PgQuery.MergeAction.t()} | {:coerce_to_domain, PgQuery.CoerceToDomain.t()} | {:coerce_to_domain_value, PgQuery.CoerceToDomainValue.t()} | {:set_to_default, PgQuery.SetToDefault.t()} | {:current_of_expr, PgQuery.CurrentOfExpr.t()} | {:next_value_expr, PgQuery.NextValueExpr.t()} | {:inference_elem, PgQuery.InferenceElem.t()} | {:target_entry, PgQuery.TargetEntry.t()} | {:range_tbl_ref, PgQuery.RangeTblRef.t()} | {:join_expr, PgQuery.JoinExpr.t()} | {:from_expr, PgQuery.FromExpr.t()} | {:on_conflict_expr, PgQuery.OnConflictExpr.t()} | {:query, PgQuery.Query.t()} | {:type_name, PgQuery.TypeName.t()} | {:column_ref, PgQuery.ColumnRef.t()} | {:param_ref, PgQuery.ParamRef.t()} | {:a_expr, PgQuery.A_Expr.t()} | {:type_cast, PgQuery.TypeCast.t()} | {:collate_clause, PgQuery.CollateClause.t()} | {:role_spec, PgQuery.RoleSpec.t()} | {:func_call, PgQuery.FuncCall.t()} | {:a_star, PgQuery.A_Star.t()} | {:a_indices, PgQuery.A_Indices.t()} | {:a_indirection, PgQuery.A_Indirection.t()} | {:a_array_expr, PgQuery.A_ArrayExpr.t()} | {:res_target, PgQuery.ResTarget.t()} | {:multi_assign_ref, PgQuery.MultiAssignRef.t()} | {:sort_by, PgQuery.SortBy.t()} | {:window_def, PgQuery.WindowDef.t()} | {:range_subselect, PgQuery.RangeSubselect.t()} | {:range_function, PgQuery.RangeFunction.t()} | {:range_table_func, PgQuery.RangeTableFunc.t()} | {:range_table_func_col, PgQuery.RangeTableFuncCol.t()} | {:range_table_sample, PgQuery.RangeTableSample.t()} | {:column_def, PgQuery.ColumnDef.t()} | {:table_like_clause, PgQuery.TableLikeClause.t()} | {:index_elem, PgQuery.IndexElem.t()} | {:def_elem, PgQuery.DefElem.t()} | {:locking_clause, PgQuery.LockingClause.t()} | {:xml_serialize, PgQuery.XmlSerialize.t()} | {:partition_elem, PgQuery.PartitionElem.t()} | {:partition_spec, PgQuery.PartitionSpec.t()} | {:partition_bound_spec, PgQuery.PartitionBoundSpec.t()} | {:partition_range_datum, PgQuery.PartitionRangeDatum.t()} | {:single_partition_spec, PgQuery.SinglePartitionSpec.t()} | {:partition_cmd, PgQuery.PartitionCmd.t()} | {:range_tbl_entry, PgQuery.RangeTblEntry.t()} | {:rtepermission_info, PgQuery.RTEPermissionInfo.t()} | {:range_tbl_function, PgQuery.RangeTblFunction.t()} | {:table_sample_clause, PgQuery.TableSampleClause.t()} | {:with_check_option, PgQuery.WithCheckOption.t()} | {:sort_group_clause, PgQuery.SortGroupClause.t()} | {:grouping_set, PgQuery.GroupingSet.t()} | {:window_clause, PgQuery.WindowClause.t()} | {:row_mark_clause, PgQuery.RowMarkClause.t()} | {:with_clause, PgQuery.WithClause.t()} | {:infer_clause, PgQuery.InferClause.t()} | {:on_conflict_clause, PgQuery.OnConflictClause.t()} | {:ctesearch_clause, PgQuery.CTESearchClause.t()} | {:ctecycle_clause, PgQuery.CTECycleClause.t()} | {:common_table_expr, PgQuery.CommonTableExpr.t()} | {:merge_when_clause, PgQuery.MergeWhenClause.t()} | {:trigger_transition, PgQuery.TriggerTransition.t()} | {:json_output, PgQuery.JsonOutput.t()} | {:json_argument, PgQuery.JsonArgument.t()} | {:json_func_expr, PgQuery.JsonFuncExpr.t()} | {:json_table_path_spec, PgQuery.JsonTablePathSpec.t()} | {:json_table, PgQuery.JsonTable.t()} | {:json_table_column, PgQuery.JsonTableColumn.t()} | {:json_key_value, PgQuery.JsonKeyValue.t()} | {:json_parse_expr, PgQuery.JsonParseExpr.t()} | {:json_scalar_expr, PgQuery.JsonScalarExpr.t()} | {:json_serialize_expr, PgQuery.JsonSerializeExpr.t()} | {:json_object_constructor, PgQuery.JsonObjectConstructor.t()} | {:json_array_constructor, PgQuery.JsonArrayConstructor.t()} | {:json_array_query_constructor, PgQuery.JsonArrayQueryConstructor.t()} | {:json_agg_constructor, PgQuery.JsonAggConstructor.t()} | {:json_object_agg, PgQuery.JsonObjectAgg.t()} | {:json_array_agg, PgQuery.JsonArrayAgg.t()} | {:raw_stmt, PgQuery.RawStmt.t()} | {:insert_stmt, PgQuery.InsertStmt.t()} | {:delete_stmt, PgQuery.DeleteStmt.t()} | {:update_stmt, PgQuery.UpdateStmt.t()} | {:merge_stmt, PgQuery.MergeStmt.t()} | {:select_stmt, PgQuery.SelectStmt.t()} | {:set_operation_stmt, PgQuery.SetOperationStmt.t()} | {:return_stmt, PgQuery.ReturnStmt.t()} | {:plassign_stmt, PgQuery.PLAssignStmt.t()} | {:create_schema_stmt, PgQuery.CreateSchemaStmt.t()} | {:alter_table_stmt, PgQuery.AlterTableStmt.t()} | {:replica_identity_stmt, PgQuery.ReplicaIdentityStmt.t()} | {:alter_table_cmd, PgQuery.AlterTableCmd.t()} | {:alter_collation_stmt, PgQuery.AlterCollationStmt.t()} | {:alter_domain_stmt, PgQuery.AlterDomainStmt.t()} | {:grant_stmt, PgQuery.GrantStmt.t()} | {:object_with_args, PgQuery.ObjectWithArgs.t()} | {:access_priv, PgQuery.AccessPriv.t()} | {:grant_role_stmt, PgQuery.GrantRoleStmt.t()} | {:alter_default_privileges_stmt, PgQuery.AlterDefaultPrivilegesStmt.t()} | {:copy_stmt, PgQuery.CopyStmt.t()} | {:variable_set_stmt, PgQuery.VariableSetStmt.t()} | {:variable_show_stmt, PgQuery.VariableShowStmt.t()} | {:create_stmt, PgQuery.CreateStmt.t()} | {:constraint, PgQuery.Constraint.t()} | {:create_table_space_stmt, PgQuery.CreateTableSpaceStmt.t()} | {:drop_table_space_stmt, PgQuery.DropTableSpaceStmt.t()} | {:alter_table_space_options_stmt, PgQuery.AlterTableSpaceOptionsStmt.t()} | {:alter_table_move_all_stmt, PgQuery.AlterTableMoveAllStmt.t()} | {:create_extension_stmt, PgQuery.CreateExtensionStmt.t()} | {:alter_extension_stmt, PgQuery.AlterExtensionStmt.t()} | {:alter_extension_contents_stmt, PgQuery.AlterExtensionContentsStmt.t()} | {:create_fdw_stmt, PgQuery.CreateFdwStmt.t()} | {:alter_fdw_stmt, PgQuery.AlterFdwStmt.t()} | {:create_foreign_server_stmt, PgQuery.CreateForeignServerStmt.t()} | {:alter_foreign_server_stmt, PgQuery.AlterForeignServerStmt.t()} | {:create_foreign_table_stmt, PgQuery.CreateForeignTableStmt.t()} | {:create_user_mapping_stmt, PgQuery.CreateUserMappingStmt.t()} | {:alter_user_mapping_stmt, PgQuery.AlterUserMappingStmt.t()} | {:drop_user_mapping_stmt, PgQuery.DropUserMappingStmt.t()} | {:import_foreign_schema_stmt, PgQuery.ImportForeignSchemaStmt.t()} | {:create_policy_stmt, PgQuery.CreatePolicyStmt.t()} | {:alter_policy_stmt, PgQuery.AlterPolicyStmt.t()} | {:create_am_stmt, PgQuery.CreateAmStmt.t()} | {:create_trig_stmt, PgQuery.CreateTrigStmt.t()} | {:create_event_trig_stmt, PgQuery.CreateEventTrigStmt.t()} | {:alter_event_trig_stmt, PgQuery.AlterEventTrigStmt.t()} | {:create_plang_stmt, PgQuery.CreatePLangStmt.t()} | {:create_role_stmt, PgQuery.CreateRoleStmt.t()} | {:alter_role_stmt, PgQuery.AlterRoleStmt.t()} | {:alter_role_set_stmt, PgQuery.AlterRoleSetStmt.t()} | {:drop_role_stmt, PgQuery.DropRoleStmt.t()} | {:create_seq_stmt, PgQuery.CreateSeqStmt.t()} | {:alter_seq_stmt, PgQuery.AlterSeqStmt.t()} | {:define_stmt, PgQuery.DefineStmt.t()} | {:create_domain_stmt, PgQuery.CreateDomainStmt.t()} | {:create_op_class_stmt, PgQuery.CreateOpClassStmt.t()} | {:create_op_class_item, PgQuery.CreateOpClassItem.t()} | {:create_op_family_stmt, PgQuery.CreateOpFamilyStmt.t()} | {:alter_op_family_stmt, PgQuery.AlterOpFamilyStmt.t()} | {:drop_stmt, PgQuery.DropStmt.t()} | {:truncate_stmt, PgQuery.TruncateStmt.t()} | {:comment_stmt, PgQuery.CommentStmt.t()} | {:sec_label_stmt, PgQuery.SecLabelStmt.t()} | {:declare_cursor_stmt, PgQuery.DeclareCursorStmt.t()} | {:close_portal_stmt, PgQuery.ClosePortalStmt.t()} | {:fetch_stmt, PgQuery.FetchStmt.t()} | {:index_stmt, PgQuery.IndexStmt.t()} | {:create_stats_stmt, PgQuery.CreateStatsStmt.t()} | {:stats_elem, PgQuery.StatsElem.t()} | {:alter_stats_stmt, PgQuery.AlterStatsStmt.t()} | {:create_function_stmt, PgQuery.CreateFunctionStmt.t()} | {:function_parameter, PgQuery.FunctionParameter.t()} | {:alter_function_stmt, PgQuery.AlterFunctionStmt.t()} | {:do_stmt, PgQuery.DoStmt.t()} | {:inline_code_block, PgQuery.InlineCodeBlock.t()} | {:call_stmt, PgQuery.CallStmt.t()} | {:call_context, PgQuery.CallContext.t()} | {:rename_stmt, PgQuery.RenameStmt.t()} | {:alter_object_depends_stmt, PgQuery.AlterObjectDependsStmt.t()} | {:alter_object_schema_stmt, PgQuery.AlterObjectSchemaStmt.t()} | {:alter_owner_stmt, PgQuery.AlterOwnerStmt.t()} | {:alter_operator_stmt, PgQuery.AlterOperatorStmt.t()} | {:alter_type_stmt, PgQuery.AlterTypeStmt.t()} | {:rule_stmt, PgQuery.RuleStmt.t()} | {:notify_stmt, PgQuery.NotifyStmt.t()} | {:listen_stmt, PgQuery.ListenStmt.t()} | {:unlisten_stmt, PgQuery.UnlistenStmt.t()} | {:transaction_stmt, PgQuery.TransactionStmt.t()} | {:composite_type_stmt, PgQuery.CompositeTypeStmt.t()} | {:create_enum_stmt, PgQuery.CreateEnumStmt.t()} | {:create_range_stmt, PgQuery.CreateRangeStmt.t()} | {:alter_enum_stmt, PgQuery.AlterEnumStmt.t()} | {:view_stmt, PgQuery.ViewStmt.t()} | {:load_stmt, PgQuery.LoadStmt.t()} | {:createdb_stmt, PgQuery.CreatedbStmt.t()} | {:alter_database_stmt, PgQuery.AlterDatabaseStmt.t()} | {:alter_database_refresh_coll_stmt, PgQuery.AlterDatabaseRefreshCollStmt.t()} | {:alter_database_set_stmt, PgQuery.AlterDatabaseSetStmt.t()} | {:dropdb_stmt, PgQuery.DropdbStmt.t()} | {:alter_system_stmt, PgQuery.AlterSystemStmt.t()} | {:cluster_stmt, PgQuery.ClusterStmt.t()} | {:vacuum_stmt, PgQuery.VacuumStmt.t()} | {:vacuum_relation, PgQuery.VacuumRelation.t()} | {:explain_stmt, PgQuery.ExplainStmt.t()} | {:create_table_as_stmt, PgQuery.CreateTableAsStmt.t()} | {:refresh_mat_view_stmt, PgQuery.RefreshMatViewStmt.t()} | {:check_point_stmt, PgQuery.CheckPointStmt.t()} | {:discard_stmt, PgQuery.DiscardStmt.t()} | {:lock_stmt, PgQuery.LockStmt.t()} | {:constraints_set_stmt, PgQuery.ConstraintsSetStmt.t()} | {:reindex_stmt, PgQuery.ReindexStmt.t()} | {:create_conversion_stmt, PgQuery.CreateConversionStmt.t()} | {:create_cast_stmt, PgQuery.CreateCastStmt.t()} | {:create_transform_stmt, PgQuery.CreateTransformStmt.t()} | {:prepare_stmt, PgQuery.PrepareStmt.t()} | {:execute_stmt, PgQuery.ExecuteStmt.t()} | {:deallocate_stmt, PgQuery.DeallocateStmt.t()} | {:drop_owned_stmt, PgQuery.DropOwnedStmt.t()} | {:reassign_owned_stmt, PgQuery.ReassignOwnedStmt.t()} | {:alter_tsdictionary_stmt, PgQuery.AlterTSDictionaryStmt.t()} | {:alter_tsconfiguration_stmt, PgQuery.AlterTSConfigurationStmt.t()} | {:publication_table, PgQuery.PublicationTable.t()} | {:publication_obj_spec, PgQuery.PublicationObjSpec.t()} | {:create_publication_stmt, PgQuery.CreatePublicationStmt.t()} | {:alter_publication_stmt, PgQuery.AlterPublicationStmt.t()} | {:create_subscription_stmt, PgQuery.CreateSubscriptionStmt.t()} | {:alter_subscription_stmt, PgQuery.AlterSubscriptionStmt.t()} | {:drop_subscription_stmt, PgQuery.DropSubscriptionStmt.t()} | {:integer, PgQuery.Integer.t()} | {:float, PgQuery.Float.t()} | {:boolean, PgQuery.Boolean.t()} | {:string, PgQuery.String.t()} | {:bit_string, PgQuery.BitString.t()} | {:list, PgQuery.List.t()} | {:int_list, PgQuery.IntList.t()} | {:oid_list, PgQuery.OidList.t()} | {:a_const, PgQuery.A_Const.t()} | nil, __uf__: [{non_neg_integer(), Protox.Types.tag(), binary()}] } defstruct node: nil, __uf__: [] ( ( @spec encode(t()) :: {:ok, iodata(), non_neg_integer()} | {:error, any()} def encode(msg) do msg |> encode!() |> Tuple.insert_at(0, :ok) rescue e in [Protox.EncodingError, Protox.RequiredFieldsError] -> {:error, e} end @spec encode!(t()) :: {iodata(), non_neg_integer()} | no_return() def encode!(msg) do {_acc = [], _acc_size = 0} |> encode_node(msg) |> encode_unknown_fields(msg) end ) defp encode_node({acc, acc_size}, msg) do case msg.node do nil -> {acc, acc_size} {:a_const, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:oid_list, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:int_list, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:list, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:bit_string, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:string, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:boolean, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:float, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:integer, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:drop_subscription_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_subscription_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_subscription_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_publication_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x10", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_publication_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:publication_obj_spec, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:publication_table, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_tsconfiguration_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_tsdictionary_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:reassign_owned_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:drop_owned_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:deallocate_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:execute_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:prepare_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_transform_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_cast_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_conversion_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:reindex_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:constraints_set_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:lock_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x0F", value_bytes | acc], acc_size + 2 + value_bytes_size} {:discard_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:check_point_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:refresh_mat_view_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_table_as_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:explain_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:vacuum_relation, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:vacuum_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:cluster_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_system_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:dropdb_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_database_set_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_database_refresh_coll_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_database_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:createdb_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:load_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:view_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x0E", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_enum_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_range_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_enum_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:composite_type_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:transaction_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:unlisten_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:listen_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:notify_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:rule_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_type_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_operator_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_owner_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_object_schema_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_object_depends_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:rename_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:call_context, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\r", value_bytes | acc], acc_size + 2 + value_bytes_size} {:call_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:inline_code_block, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:do_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_function_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:function_parameter, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_function_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_stats_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:stats_elem, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_stats_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:index_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:fetch_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:close_portal_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:declare_cursor_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:sec_label_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:comment_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:truncate_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\f", value_bytes | acc], acc_size + 2 + value_bytes_size} {:drop_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_op_family_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_op_family_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_op_class_item, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_op_class_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_domain_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:define_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_seq_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_seq_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:drop_role_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_role_set_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_role_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_role_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_plang_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_event_trig_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_event_trig_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\v", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_trig_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_am_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_policy_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_policy_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:import_foreign_schema_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:drop_user_mapping_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_user_mapping_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_user_mapping_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_foreign_table_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_foreign_server_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_foreign_server_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_fdw_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_fdw_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_extension_contents_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_extension_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_extension_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\n", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_table_move_all_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_table_space_options_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:drop_table_space_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_table_space_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:constraint, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:variable_show_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:variable_set_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:copy_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_default_privileges_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:grant_role_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:access_priv, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:object_with_args, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:grant_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_domain_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_collation_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\t", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_table_cmd, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:replica_identity_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alter_table_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:create_schema_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:plassign_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:return_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:set_operation_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:select_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:merge_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:update_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:delete_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:insert_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:raw_stmt, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_array_agg, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_object_agg, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_agg_constructor, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\b", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_array_query_constructor, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_array_constructor, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_object_constructor, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_serialize_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_scalar_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_parse_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_key_value, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_table_column, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_table, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_table_path_spec, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_func_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_argument, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_output, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:trigger_transition, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:merge_when_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:common_table_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\a", value_bytes | acc], acc_size + 2 + value_bytes_size} {:ctecycle_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:ctesearch_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:on_conflict_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:infer_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:with_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:row_mark_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:window_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:grouping_set, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:sort_group_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:with_check_option, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:table_sample_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_tbl_function, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:rtepermission_info, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_tbl_entry, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:partition_cmd, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:single_partition_spec, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x06", value_bytes | acc], acc_size + 2 + value_bytes_size} {:partition_range_datum, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:partition_bound_spec, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:partition_spec, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:partition_elem, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:xml_serialize, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:locking_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:def_elem, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:index_elem, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:table_like_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:column_def, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_table_sample, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_table_func_col, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_table_func, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_function, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_subselect, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:window_def, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x05", value_bytes | acc], acc_size + 2 + value_bytes_size} {:sort_by, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:multi_assign_ref, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:res_target, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:a_array_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:a_indirection, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:a_indices, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:a_star, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:func_call, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:role_spec, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:collate_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:type_cast, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:a_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:param_ref, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:column_ref, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:type_name, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:query, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x04", value_bytes | acc], acc_size + 2 + value_bytes_size} {:on_conflict_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:from_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:join_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:range_tbl_ref, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:target_entry, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:inference_elem, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:next_value_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:current_of_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:set_to_default, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:coerce_to_domain_value, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:coerce_to_domain, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:merge_action, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:boolean_test, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:null_test, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_table_sibling_join, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_table_path_scan, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x03", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_table_path, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_behavior, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_is_predicate, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_constructor_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_value_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_returning, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:json_format, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:xml_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:sqlvalue_function, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:min_max_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:coalesce_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:row_compare_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:row_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:array_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:case_test_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x02", value_bytes | acc], acc_size + 2 + value_bytes_size} {:case_when, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xFA\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:case_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xF2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:collate_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xEA\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:convert_rowtype_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xE2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:array_coerce_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xDA\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:coerce_via_io, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xD2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:relabel_type, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xCA\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:field_store, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xC2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:field_select, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xBA\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:alternative_sub_plan, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xB2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:sub_plan, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xAA\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:sub_link, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\xA2\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:bool_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x9A\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:scalar_array_op_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x92\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:null_if_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x8A\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:distinct_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x82\x01", value_bytes | acc], acc_size + 2 + value_bytes_size} {:op_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["z", value_bytes | acc], acc_size + 1 + value_bytes_size} {:named_arg_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["r", value_bytes | acc], acc_size + 1 + value_bytes_size} {:func_expr, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["j", value_bytes | acc], acc_size + 1 + value_bytes_size} {:subscripting_ref, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["b", value_bytes | acc], acc_size + 1 + value_bytes_size} {:merge_support_func, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["Z", value_bytes | acc], acc_size + 1 + value_bytes_size} {:window_func_run_condition, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["R", value_bytes | acc], acc_size + 1 + value_bytes_size} {:window_func, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["J", value_bytes | acc], acc_size + 1 + value_bytes_size} {:grouping_func, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["B", value_bytes | acc], acc_size + 1 + value_bytes_size} {:aggref, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {[":", value_bytes | acc], acc_size + 1 + value_bytes_size} {:param, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["2", value_bytes | acc], acc_size + 1 + value_bytes_size} {:var, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["*", value_bytes | acc], acc_size + 1 + value_bytes_size} {:into_clause, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\"", value_bytes | acc], acc_size + 1 + value_bytes_size} {:table_func, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x1A", value_bytes | acc], acc_size + 1 + value_bytes_size} {:range_var, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\x12", value_bytes | acc], acc_size + 1 + value_bytes_size} {:alias, child_field_value} -> {value_bytes, value_bytes_size} = Protox.Encode.encode_message(child_field_value) {["\n", value_bytes | acc], acc_size + 1 + value_bytes_size} end end defp encode_unknown_fields({acc, acc_size}, msg) do Enum.reduce(msg.__uf__, {acc, acc_size}, fn {tag, wire_type, bytes}, {acc, acc_size} -> case wire_type do 0 -> {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :int32) {[acc, <>], acc_size + key_size + byte_size(bytes)} 1 -> {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :double) {[acc, <>], acc_size + key_size + byte_size(bytes)} 2 -> {len_bytes, len_size} = bytes |> byte_size() |> Protox.Varint.encode() {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :packed) {[acc, <>], acc_size + key_size + len_size + byte_size(bytes)} 5 -> {key_bytes, key_size} = Protox.Encode.make_key_bytes(tag, :float) {[acc, <>], acc_size + key_size + byte_size(bytes)} end end) end ) ( ( @spec decode(binary()) :: {:ok, t()} | {:error, any()} def decode(bytes) do {:ok, decode!(bytes)} rescue e in [Protox.DecodingError, Protox.IllegalTagError, Protox.RequiredFieldsError] -> {:error, e} end ( @spec decode!(binary()) :: t() | no_return() def decode!(bytes) do parse_key_value(bytes, struct(PgQuery.Node)) end ) ) ( @spec parse_key_value(binary(), struct()) :: struct() defp parse_key_value(<<>>, msg) do msg end defp parse_key_value(bytes, msg) do {field, rest} = case bytes do <<_::5, 3::3, _rest::binary>> -> raise Protox.DecodingError.new(bytes, "invalid wire type 3") <<_::5, 4::3, _rest::binary>> -> raise Protox.DecodingError.new(bytes, "invalid wire type 4") <<_::5, 6::3, _rest::binary>> -> raise Protox.DecodingError.new(bytes, "invalid wire type 6") <<_::5, 7::3, _rest::binary>> -> raise Protox.DecodingError.new(bytes, "invalid wire type 7") <<0::5, _::3, _rest::binary>> -> raise %Protox.IllegalTagError{} <<28::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:a_const, previous_value} -> {:node, {:a_const, Protox.MergeMessage.merge( previous_value, PgQuery.A_Const.decode!(delimited) )}} _ -> {:node, {:a_const, PgQuery.A_Const.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:oid_list, previous_value} -> {:node, {:oid_list, Protox.MergeMessage.merge( previous_value, PgQuery.OidList.decode!(delimited) )}} _ -> {:node, {:oid_list, PgQuery.OidList.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:int_list, previous_value} -> {:node, {:int_list, Protox.MergeMessage.merge( previous_value, PgQuery.IntList.decode!(delimited) )}} _ -> {:node, {:int_list, PgQuery.IntList.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:list, previous_value} -> {:node, {:list, Protox.MergeMessage.merge(previous_value, PgQuery.List.decode!(delimited))}} _ -> {:node, {:list, PgQuery.List.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:bit_string, previous_value} -> {:node, {:bit_string, Protox.MergeMessage.merge( previous_value, PgQuery.BitString.decode!(delimited) )}} _ -> {:node, {:bit_string, PgQuery.BitString.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:string, previous_value} -> {:node, {:string, Protox.MergeMessage.merge( previous_value, PgQuery.String.decode!(delimited) )}} _ -> {:node, {:string, PgQuery.String.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:boolean, previous_value} -> {:node, {:boolean, Protox.MergeMessage.merge( previous_value, PgQuery.Boolean.decode!(delimited) )}} _ -> {:node, {:boolean, PgQuery.Boolean.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:float, previous_value} -> {:node, {:float, Protox.MergeMessage.merge(previous_value, PgQuery.Float.decode!(delimited))}} _ -> {:node, {:float, PgQuery.Float.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:integer, previous_value} -> {:node, {:integer, Protox.MergeMessage.merge( previous_value, PgQuery.Integer.decode!(delimited) )}} _ -> {:node, {:integer, PgQuery.Integer.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:drop_subscription_stmt, previous_value} -> {:node, {:drop_subscription_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DropSubscriptionStmt.decode!(delimited) )}} _ -> {:node, {:drop_subscription_stmt, PgQuery.DropSubscriptionStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_subscription_stmt, previous_value} -> {:node, {:alter_subscription_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterSubscriptionStmt.decode!(delimited) )}} _ -> {:node, {:alter_subscription_stmt, PgQuery.AlterSubscriptionStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_subscription_stmt, previous_value} -> {:node, {:create_subscription_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateSubscriptionStmt.decode!(delimited) )}} _ -> {:node, {:create_subscription_stmt, PgQuery.CreateSubscriptionStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x10", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_publication_stmt, previous_value} -> {:node, {:alter_publication_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterPublicationStmt.decode!(delimited) )}} _ -> {:node, {:alter_publication_stmt, PgQuery.AlterPublicationStmt.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_publication_stmt, previous_value} -> {:node, {:create_publication_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreatePublicationStmt.decode!(delimited) )}} _ -> {:node, {:create_publication_stmt, PgQuery.CreatePublicationStmt.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:publication_obj_spec, previous_value} -> {:node, {:publication_obj_spec, Protox.MergeMessage.merge( previous_value, PgQuery.PublicationObjSpec.decode!(delimited) )}} _ -> {:node, {:publication_obj_spec, PgQuery.PublicationObjSpec.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:publication_table, previous_value} -> {:node, {:publication_table, Protox.MergeMessage.merge( previous_value, PgQuery.PublicationTable.decode!(delimited) )}} _ -> {:node, {:publication_table, PgQuery.PublicationTable.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_tsconfiguration_stmt, previous_value} -> {:node, {:alter_tsconfiguration_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterTSConfigurationStmt.decode!(delimited) )}} _ -> {:node, {:alter_tsconfiguration_stmt, PgQuery.AlterTSConfigurationStmt.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_tsdictionary_stmt, previous_value} -> {:node, {:alter_tsdictionary_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterTSDictionaryStmt.decode!(delimited) )}} _ -> {:node, {:alter_tsdictionary_stmt, PgQuery.AlterTSDictionaryStmt.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:reassign_owned_stmt, previous_value} -> {:node, {:reassign_owned_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ReassignOwnedStmt.decode!(delimited) )}} _ -> {:node, {:reassign_owned_stmt, PgQuery.ReassignOwnedStmt.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:drop_owned_stmt, previous_value} -> {:node, {:drop_owned_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DropOwnedStmt.decode!(delimited) )}} _ -> {:node, {:drop_owned_stmt, PgQuery.DropOwnedStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:deallocate_stmt, previous_value} -> {:node, {:deallocate_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DeallocateStmt.decode!(delimited) )}} _ -> {:node, {:deallocate_stmt, PgQuery.DeallocateStmt.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:execute_stmt, previous_value} -> {:node, {:execute_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ExecuteStmt.decode!(delimited) )}} _ -> {:node, {:execute_stmt, PgQuery.ExecuteStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:prepare_stmt, previous_value} -> {:node, {:prepare_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.PrepareStmt.decode!(delimited) )}} _ -> {:node, {:prepare_stmt, PgQuery.PrepareStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_transform_stmt, previous_value} -> {:node, {:create_transform_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateTransformStmt.decode!(delimited) )}} _ -> {:node, {:create_transform_stmt, PgQuery.CreateTransformStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_cast_stmt, previous_value} -> {:node, {:create_cast_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateCastStmt.decode!(delimited) )}} _ -> {:node, {:create_cast_stmt, PgQuery.CreateCastStmt.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_conversion_stmt, previous_value} -> {:node, {:create_conversion_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateConversionStmt.decode!(delimited) )}} _ -> {:node, {:create_conversion_stmt, PgQuery.CreateConversionStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:reindex_stmt, previous_value} -> {:node, {:reindex_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ReindexStmt.decode!(delimited) )}} _ -> {:node, {:reindex_stmt, PgQuery.ReindexStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:constraints_set_stmt, previous_value} -> {:node, {:constraints_set_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ConstraintsSetStmt.decode!(delimited) )}} _ -> {:node, {:constraints_set_stmt, PgQuery.ConstraintsSetStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x0F", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:lock_stmt, previous_value} -> {:node, {:lock_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.LockStmt.decode!(delimited) )}} _ -> {:node, {:lock_stmt, PgQuery.LockStmt.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:discard_stmt, previous_value} -> {:node, {:discard_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DiscardStmt.decode!(delimited) )}} _ -> {:node, {:discard_stmt, PgQuery.DiscardStmt.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:check_point_stmt, previous_value} -> {:node, {:check_point_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CheckPointStmt.decode!(delimited) )}} _ -> {:node, {:check_point_stmt, PgQuery.CheckPointStmt.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:refresh_mat_view_stmt, previous_value} -> {:node, {:refresh_mat_view_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.RefreshMatViewStmt.decode!(delimited) )}} _ -> {:node, {:refresh_mat_view_stmt, PgQuery.RefreshMatViewStmt.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_table_as_stmt, previous_value} -> {:node, {:create_table_as_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateTableAsStmt.decode!(delimited) )}} _ -> {:node, {:create_table_as_stmt, PgQuery.CreateTableAsStmt.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:explain_stmt, previous_value} -> {:node, {:explain_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ExplainStmt.decode!(delimited) )}} _ -> {:node, {:explain_stmt, PgQuery.ExplainStmt.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:vacuum_relation, previous_value} -> {:node, {:vacuum_relation, Protox.MergeMessage.merge( previous_value, PgQuery.VacuumRelation.decode!(delimited) )}} _ -> {:node, {:vacuum_relation, PgQuery.VacuumRelation.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:vacuum_stmt, previous_value} -> {:node, {:vacuum_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.VacuumStmt.decode!(delimited) )}} _ -> {:node, {:vacuum_stmt, PgQuery.VacuumStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:cluster_stmt, previous_value} -> {:node, {:cluster_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ClusterStmt.decode!(delimited) )}} _ -> {:node, {:cluster_stmt, PgQuery.ClusterStmt.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_system_stmt, previous_value} -> {:node, {:alter_system_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterSystemStmt.decode!(delimited) )}} _ -> {:node, {:alter_system_stmt, PgQuery.AlterSystemStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:dropdb_stmt, previous_value} -> {:node, {:dropdb_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DropdbStmt.decode!(delimited) )}} _ -> {:node, {:dropdb_stmt, PgQuery.DropdbStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_database_set_stmt, previous_value} -> {:node, {:alter_database_set_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterDatabaseSetStmt.decode!(delimited) )}} _ -> {:node, {:alter_database_set_stmt, PgQuery.AlterDatabaseSetStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_database_refresh_coll_stmt, previous_value} -> {:node, {:alter_database_refresh_coll_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterDatabaseRefreshCollStmt.decode!(delimited) )}} _ -> {:node, {:alter_database_refresh_coll_stmt, PgQuery.AlterDatabaseRefreshCollStmt.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_database_stmt, previous_value} -> {:node, {:alter_database_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterDatabaseStmt.decode!(delimited) )}} _ -> {:node, {:alter_database_stmt, PgQuery.AlterDatabaseStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:createdb_stmt, previous_value} -> {:node, {:createdb_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreatedbStmt.decode!(delimited) )}} _ -> {:node, {:createdb_stmt, PgQuery.CreatedbStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:load_stmt, previous_value} -> {:node, {:load_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.LoadStmt.decode!(delimited) )}} _ -> {:node, {:load_stmt, PgQuery.LoadStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x0E", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:view_stmt, previous_value} -> {:node, {:view_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ViewStmt.decode!(delimited) )}} _ -> {:node, {:view_stmt, PgQuery.ViewStmt.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_enum_stmt, previous_value} -> {:node, {:alter_enum_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterEnumStmt.decode!(delimited) )}} _ -> {:node, {:alter_enum_stmt, PgQuery.AlterEnumStmt.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_range_stmt, previous_value} -> {:node, {:create_range_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateRangeStmt.decode!(delimited) )}} _ -> {:node, {:create_range_stmt, PgQuery.CreateRangeStmt.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_enum_stmt, previous_value} -> {:node, {:create_enum_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateEnumStmt.decode!(delimited) )}} _ -> {:node, {:create_enum_stmt, PgQuery.CreateEnumStmt.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:composite_type_stmt, previous_value} -> {:node, {:composite_type_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CompositeTypeStmt.decode!(delimited) )}} _ -> {:node, {:composite_type_stmt, PgQuery.CompositeTypeStmt.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:transaction_stmt, previous_value} -> {:node, {:transaction_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.TransactionStmt.decode!(delimited) )}} _ -> {:node, {:transaction_stmt, PgQuery.TransactionStmt.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:unlisten_stmt, previous_value} -> {:node, {:unlisten_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.UnlistenStmt.decode!(delimited) )}} _ -> {:node, {:unlisten_stmt, PgQuery.UnlistenStmt.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:listen_stmt, previous_value} -> {:node, {:listen_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ListenStmt.decode!(delimited) )}} _ -> {:node, {:listen_stmt, PgQuery.ListenStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:notify_stmt, previous_value} -> {:node, {:notify_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.NotifyStmt.decode!(delimited) )}} _ -> {:node, {:notify_stmt, PgQuery.NotifyStmt.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:rule_stmt, previous_value} -> {:node, {:rule_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.RuleStmt.decode!(delimited) )}} _ -> {:node, {:rule_stmt, PgQuery.RuleStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_type_stmt, previous_value} -> {:node, {:alter_type_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterTypeStmt.decode!(delimited) )}} _ -> {:node, {:alter_type_stmt, PgQuery.AlterTypeStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_operator_stmt, previous_value} -> {:node, {:alter_operator_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterOperatorStmt.decode!(delimited) )}} _ -> {:node, {:alter_operator_stmt, PgQuery.AlterOperatorStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_owner_stmt, previous_value} -> {:node, {:alter_owner_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterOwnerStmt.decode!(delimited) )}} _ -> {:node, {:alter_owner_stmt, PgQuery.AlterOwnerStmt.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_object_schema_stmt, previous_value} -> {:node, {:alter_object_schema_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterObjectSchemaStmt.decode!(delimited) )}} _ -> {:node, {:alter_object_schema_stmt, PgQuery.AlterObjectSchemaStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_object_depends_stmt, previous_value} -> {:node, {:alter_object_depends_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterObjectDependsStmt.decode!(delimited) )}} _ -> {:node, {:alter_object_depends_stmt, PgQuery.AlterObjectDependsStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:rename_stmt, previous_value} -> {:node, {:rename_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.RenameStmt.decode!(delimited) )}} _ -> {:node, {:rename_stmt, PgQuery.RenameStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\r", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:call_context, previous_value} -> {:node, {:call_context, Protox.MergeMessage.merge( previous_value, PgQuery.CallContext.decode!(delimited) )}} _ -> {:node, {:call_context, PgQuery.CallContext.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:call_stmt, previous_value} -> {:node, {:call_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CallStmt.decode!(delimited) )}} _ -> {:node, {:call_stmt, PgQuery.CallStmt.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:inline_code_block, previous_value} -> {:node, {:inline_code_block, Protox.MergeMessage.merge( previous_value, PgQuery.InlineCodeBlock.decode!(delimited) )}} _ -> {:node, {:inline_code_block, PgQuery.InlineCodeBlock.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:do_stmt, previous_value} -> {:node, {:do_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DoStmt.decode!(delimited) )}} _ -> {:node, {:do_stmt, PgQuery.DoStmt.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_function_stmt, previous_value} -> {:node, {:alter_function_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterFunctionStmt.decode!(delimited) )}} _ -> {:node, {:alter_function_stmt, PgQuery.AlterFunctionStmt.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:function_parameter, previous_value} -> {:node, {:function_parameter, Protox.MergeMessage.merge( previous_value, PgQuery.FunctionParameter.decode!(delimited) )}} _ -> {:node, {:function_parameter, PgQuery.FunctionParameter.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_function_stmt, previous_value} -> {:node, {:create_function_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateFunctionStmt.decode!(delimited) )}} _ -> {:node, {:create_function_stmt, PgQuery.CreateFunctionStmt.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_stats_stmt, previous_value} -> {:node, {:alter_stats_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterStatsStmt.decode!(delimited) )}} _ -> {:node, {:alter_stats_stmt, PgQuery.AlterStatsStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:stats_elem, previous_value} -> {:node, {:stats_elem, Protox.MergeMessage.merge( previous_value, PgQuery.StatsElem.decode!(delimited) )}} _ -> {:node, {:stats_elem, PgQuery.StatsElem.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_stats_stmt, previous_value} -> {:node, {:create_stats_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateStatsStmt.decode!(delimited) )}} _ -> {:node, {:create_stats_stmt, PgQuery.CreateStatsStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:index_stmt, previous_value} -> {:node, {:index_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.IndexStmt.decode!(delimited) )}} _ -> {:node, {:index_stmt, PgQuery.IndexStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:fetch_stmt, previous_value} -> {:node, {:fetch_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.FetchStmt.decode!(delimited) )}} _ -> {:node, {:fetch_stmt, PgQuery.FetchStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:close_portal_stmt, previous_value} -> {:node, {:close_portal_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ClosePortalStmt.decode!(delimited) )}} _ -> {:node, {:close_portal_stmt, PgQuery.ClosePortalStmt.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:declare_cursor_stmt, previous_value} -> {:node, {:declare_cursor_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DeclareCursorStmt.decode!(delimited) )}} _ -> {:node, {:declare_cursor_stmt, PgQuery.DeclareCursorStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:sec_label_stmt, previous_value} -> {:node, {:sec_label_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.SecLabelStmt.decode!(delimited) )}} _ -> {:node, {:sec_label_stmt, PgQuery.SecLabelStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:comment_stmt, previous_value} -> {:node, {:comment_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CommentStmt.decode!(delimited) )}} _ -> {:node, {:comment_stmt, PgQuery.CommentStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\f", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:truncate_stmt, previous_value} -> {:node, {:truncate_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.TruncateStmt.decode!(delimited) )}} _ -> {:node, {:truncate_stmt, PgQuery.TruncateStmt.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:drop_stmt, previous_value} -> {:node, {:drop_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DropStmt.decode!(delimited) )}} _ -> {:node, {:drop_stmt, PgQuery.DropStmt.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_op_family_stmt, previous_value} -> {:node, {:alter_op_family_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterOpFamilyStmt.decode!(delimited) )}} _ -> {:node, {:alter_op_family_stmt, PgQuery.AlterOpFamilyStmt.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_op_family_stmt, previous_value} -> {:node, {:create_op_family_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateOpFamilyStmt.decode!(delimited) )}} _ -> {:node, {:create_op_family_stmt, PgQuery.CreateOpFamilyStmt.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_op_class_item, previous_value} -> {:node, {:create_op_class_item, Protox.MergeMessage.merge( previous_value, PgQuery.CreateOpClassItem.decode!(delimited) )}} _ -> {:node, {:create_op_class_item, PgQuery.CreateOpClassItem.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_op_class_stmt, previous_value} -> {:node, {:create_op_class_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateOpClassStmt.decode!(delimited) )}} _ -> {:node, {:create_op_class_stmt, PgQuery.CreateOpClassStmt.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_domain_stmt, previous_value} -> {:node, {:create_domain_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateDomainStmt.decode!(delimited) )}} _ -> {:node, {:create_domain_stmt, PgQuery.CreateDomainStmt.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:define_stmt, previous_value} -> {:node, {:define_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DefineStmt.decode!(delimited) )}} _ -> {:node, {:define_stmt, PgQuery.DefineStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_seq_stmt, previous_value} -> {:node, {:alter_seq_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterSeqStmt.decode!(delimited) )}} _ -> {:node, {:alter_seq_stmt, PgQuery.AlterSeqStmt.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_seq_stmt, previous_value} -> {:node, {:create_seq_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateSeqStmt.decode!(delimited) )}} _ -> {:node, {:create_seq_stmt, PgQuery.CreateSeqStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:drop_role_stmt, previous_value} -> {:node, {:drop_role_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DropRoleStmt.decode!(delimited) )}} _ -> {:node, {:drop_role_stmt, PgQuery.DropRoleStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_role_set_stmt, previous_value} -> {:node, {:alter_role_set_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterRoleSetStmt.decode!(delimited) )}} _ -> {:node, {:alter_role_set_stmt, PgQuery.AlterRoleSetStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_role_stmt, previous_value} -> {:node, {:alter_role_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterRoleStmt.decode!(delimited) )}} _ -> {:node, {:alter_role_stmt, PgQuery.AlterRoleStmt.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_role_stmt, previous_value} -> {:node, {:create_role_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateRoleStmt.decode!(delimited) )}} _ -> {:node, {:create_role_stmt, PgQuery.CreateRoleStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_plang_stmt, previous_value} -> {:node, {:create_plang_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreatePLangStmt.decode!(delimited) )}} _ -> {:node, {:create_plang_stmt, PgQuery.CreatePLangStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_event_trig_stmt, previous_value} -> {:node, {:alter_event_trig_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterEventTrigStmt.decode!(delimited) )}} _ -> {:node, {:alter_event_trig_stmt, PgQuery.AlterEventTrigStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\v", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_event_trig_stmt, previous_value} -> {:node, {:create_event_trig_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateEventTrigStmt.decode!(delimited) )}} _ -> {:node, {:create_event_trig_stmt, PgQuery.CreateEventTrigStmt.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_trig_stmt, previous_value} -> {:node, {:create_trig_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateTrigStmt.decode!(delimited) )}} _ -> {:node, {:create_trig_stmt, PgQuery.CreateTrigStmt.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_am_stmt, previous_value} -> {:node, {:create_am_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateAmStmt.decode!(delimited) )}} _ -> {:node, {:create_am_stmt, PgQuery.CreateAmStmt.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_policy_stmt, previous_value} -> {:node, {:alter_policy_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterPolicyStmt.decode!(delimited) )}} _ -> {:node, {:alter_policy_stmt, PgQuery.AlterPolicyStmt.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_policy_stmt, previous_value} -> {:node, {:create_policy_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreatePolicyStmt.decode!(delimited) )}} _ -> {:node, {:create_policy_stmt, PgQuery.CreatePolicyStmt.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:import_foreign_schema_stmt, previous_value} -> {:node, {:import_foreign_schema_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ImportForeignSchemaStmt.decode!(delimited) )}} _ -> {:node, {:import_foreign_schema_stmt, PgQuery.ImportForeignSchemaStmt.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:drop_user_mapping_stmt, previous_value} -> {:node, {:drop_user_mapping_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DropUserMappingStmt.decode!(delimited) )}} _ -> {:node, {:drop_user_mapping_stmt, PgQuery.DropUserMappingStmt.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_user_mapping_stmt, previous_value} -> {:node, {:alter_user_mapping_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterUserMappingStmt.decode!(delimited) )}} _ -> {:node, {:alter_user_mapping_stmt, PgQuery.AlterUserMappingStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_user_mapping_stmt, previous_value} -> {:node, {:create_user_mapping_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateUserMappingStmt.decode!(delimited) )}} _ -> {:node, {:create_user_mapping_stmt, PgQuery.CreateUserMappingStmt.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_foreign_table_stmt, previous_value} -> {:node, {:create_foreign_table_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateForeignTableStmt.decode!(delimited) )}} _ -> {:node, {:create_foreign_table_stmt, PgQuery.CreateForeignTableStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_foreign_server_stmt, previous_value} -> {:node, {:alter_foreign_server_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterForeignServerStmt.decode!(delimited) )}} _ -> {:node, {:alter_foreign_server_stmt, PgQuery.AlterForeignServerStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_foreign_server_stmt, previous_value} -> {:node, {:create_foreign_server_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateForeignServerStmt.decode!(delimited) )}} _ -> {:node, {:create_foreign_server_stmt, PgQuery.CreateForeignServerStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_fdw_stmt, previous_value} -> {:node, {:alter_fdw_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterFdwStmt.decode!(delimited) )}} _ -> {:node, {:alter_fdw_stmt, PgQuery.AlterFdwStmt.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_fdw_stmt, previous_value} -> {:node, {:create_fdw_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateFdwStmt.decode!(delimited) )}} _ -> {:node, {:create_fdw_stmt, PgQuery.CreateFdwStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_extension_contents_stmt, previous_value} -> {:node, {:alter_extension_contents_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterExtensionContentsStmt.decode!(delimited) )}} _ -> {:node, {:alter_extension_contents_stmt, PgQuery.AlterExtensionContentsStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_extension_stmt, previous_value} -> {:node, {:alter_extension_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterExtensionStmt.decode!(delimited) )}} _ -> {:node, {:alter_extension_stmt, PgQuery.AlterExtensionStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\n", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_extension_stmt, previous_value} -> {:node, {:create_extension_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateExtensionStmt.decode!(delimited) )}} _ -> {:node, {:create_extension_stmt, PgQuery.CreateExtensionStmt.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_table_move_all_stmt, previous_value} -> {:node, {:alter_table_move_all_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterTableMoveAllStmt.decode!(delimited) )}} _ -> {:node, {:alter_table_move_all_stmt, PgQuery.AlterTableMoveAllStmt.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_table_space_options_stmt, previous_value} -> {:node, {:alter_table_space_options_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterTableSpaceOptionsStmt.decode!(delimited) )}} _ -> {:node, {:alter_table_space_options_stmt, PgQuery.AlterTableSpaceOptionsStmt.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:drop_table_space_stmt, previous_value} -> {:node, {:drop_table_space_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DropTableSpaceStmt.decode!(delimited) )}} _ -> {:node, {:drop_table_space_stmt, PgQuery.DropTableSpaceStmt.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_table_space_stmt, previous_value} -> {:node, {:create_table_space_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateTableSpaceStmt.decode!(delimited) )}} _ -> {:node, {:create_table_space_stmt, PgQuery.CreateTableSpaceStmt.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:constraint, previous_value} -> {:node, {:constraint, Protox.MergeMessage.merge( previous_value, PgQuery.Constraint.decode!(delimited) )}} _ -> {:node, {:constraint, PgQuery.Constraint.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_stmt, previous_value} -> {:node, {:create_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateStmt.decode!(delimited) )}} _ -> {:node, {:create_stmt, PgQuery.CreateStmt.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:variable_show_stmt, previous_value} -> {:node, {:variable_show_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.VariableShowStmt.decode!(delimited) )}} _ -> {:node, {:variable_show_stmt, PgQuery.VariableShowStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:variable_set_stmt, previous_value} -> {:node, {:variable_set_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.VariableSetStmt.decode!(delimited) )}} _ -> {:node, {:variable_set_stmt, PgQuery.VariableSetStmt.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:copy_stmt, previous_value} -> {:node, {:copy_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CopyStmt.decode!(delimited) )}} _ -> {:node, {:copy_stmt, PgQuery.CopyStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_default_privileges_stmt, previous_value} -> {:node, {:alter_default_privileges_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterDefaultPrivilegesStmt.decode!(delimited) )}} _ -> {:node, {:alter_default_privileges_stmt, PgQuery.AlterDefaultPrivilegesStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:grant_role_stmt, previous_value} -> {:node, {:grant_role_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.GrantRoleStmt.decode!(delimited) )}} _ -> {:node, {:grant_role_stmt, PgQuery.GrantRoleStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:access_priv, previous_value} -> {:node, {:access_priv, Protox.MergeMessage.merge( previous_value, PgQuery.AccessPriv.decode!(delimited) )}} _ -> {:node, {:access_priv, PgQuery.AccessPriv.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:object_with_args, previous_value} -> {:node, {:object_with_args, Protox.MergeMessage.merge( previous_value, PgQuery.ObjectWithArgs.decode!(delimited) )}} _ -> {:node, {:object_with_args, PgQuery.ObjectWithArgs.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:grant_stmt, previous_value} -> {:node, {:grant_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.GrantStmt.decode!(delimited) )}} _ -> {:node, {:grant_stmt, PgQuery.GrantStmt.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_domain_stmt, previous_value} -> {:node, {:alter_domain_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterDomainStmt.decode!(delimited) )}} _ -> {:node, {:alter_domain_stmt, PgQuery.AlterDomainStmt.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\t", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_collation_stmt, previous_value} -> {:node, {:alter_collation_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterCollationStmt.decode!(delimited) )}} _ -> {:node, {:alter_collation_stmt, PgQuery.AlterCollationStmt.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_table_cmd, previous_value} -> {:node, {:alter_table_cmd, Protox.MergeMessage.merge( previous_value, PgQuery.AlterTableCmd.decode!(delimited) )}} _ -> {:node, {:alter_table_cmd, PgQuery.AlterTableCmd.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:replica_identity_stmt, previous_value} -> {:node, {:replica_identity_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ReplicaIdentityStmt.decode!(delimited) )}} _ -> {:node, {:replica_identity_stmt, PgQuery.ReplicaIdentityStmt.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alter_table_stmt, previous_value} -> {:node, {:alter_table_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.AlterTableStmt.decode!(delimited) )}} _ -> {:node, {:alter_table_stmt, PgQuery.AlterTableStmt.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:create_schema_stmt, previous_value} -> {:node, {:create_schema_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.CreateSchemaStmt.decode!(delimited) )}} _ -> {:node, {:create_schema_stmt, PgQuery.CreateSchemaStmt.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:plassign_stmt, previous_value} -> {:node, {:plassign_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.PLAssignStmt.decode!(delimited) )}} _ -> {:node, {:plassign_stmt, PgQuery.PLAssignStmt.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:return_stmt, previous_value} -> {:node, {:return_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.ReturnStmt.decode!(delimited) )}} _ -> {:node, {:return_stmt, PgQuery.ReturnStmt.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:set_operation_stmt, previous_value} -> {:node, {:set_operation_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.SetOperationStmt.decode!(delimited) )}} _ -> {:node, {:set_operation_stmt, PgQuery.SetOperationStmt.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:select_stmt, previous_value} -> {:node, {:select_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.SelectStmt.decode!(delimited) )}} _ -> {:node, {:select_stmt, PgQuery.SelectStmt.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:merge_stmt, previous_value} -> {:node, {:merge_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.MergeStmt.decode!(delimited) )}} _ -> {:node, {:merge_stmt, PgQuery.MergeStmt.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:update_stmt, previous_value} -> {:node, {:update_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.UpdateStmt.decode!(delimited) )}} _ -> {:node, {:update_stmt, PgQuery.UpdateStmt.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:delete_stmt, previous_value} -> {:node, {:delete_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.DeleteStmt.decode!(delimited) )}} _ -> {:node, {:delete_stmt, PgQuery.DeleteStmt.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:insert_stmt, previous_value} -> {:node, {:insert_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.InsertStmt.decode!(delimited) )}} _ -> {:node, {:insert_stmt, PgQuery.InsertStmt.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:raw_stmt, previous_value} -> {:node, {:raw_stmt, Protox.MergeMessage.merge( previous_value, PgQuery.RawStmt.decode!(delimited) )}} _ -> {:node, {:raw_stmt, PgQuery.RawStmt.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_array_agg, previous_value} -> {:node, {:json_array_agg, Protox.MergeMessage.merge( previous_value, PgQuery.JsonArrayAgg.decode!(delimited) )}} _ -> {:node, {:json_array_agg, PgQuery.JsonArrayAgg.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_object_agg, previous_value} -> {:node, {:json_object_agg, Protox.MergeMessage.merge( previous_value, PgQuery.JsonObjectAgg.decode!(delimited) )}} _ -> {:node, {:json_object_agg, PgQuery.JsonObjectAgg.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\b", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_agg_constructor, previous_value} -> {:node, {:json_agg_constructor, Protox.MergeMessage.merge( previous_value, PgQuery.JsonAggConstructor.decode!(delimited) )}} _ -> {:node, {:json_agg_constructor, PgQuery.JsonAggConstructor.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_array_query_constructor, previous_value} -> {:node, {:json_array_query_constructor, Protox.MergeMessage.merge( previous_value, PgQuery.JsonArrayQueryConstructor.decode!(delimited) )}} _ -> {:node, {:json_array_query_constructor, PgQuery.JsonArrayQueryConstructor.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_array_constructor, previous_value} -> {:node, {:json_array_constructor, Protox.MergeMessage.merge( previous_value, PgQuery.JsonArrayConstructor.decode!(delimited) )}} _ -> {:node, {:json_array_constructor, PgQuery.JsonArrayConstructor.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_object_constructor, previous_value} -> {:node, {:json_object_constructor, Protox.MergeMessage.merge( previous_value, PgQuery.JsonObjectConstructor.decode!(delimited) )}} _ -> {:node, {:json_object_constructor, PgQuery.JsonObjectConstructor.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_serialize_expr, previous_value} -> {:node, {:json_serialize_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JsonSerializeExpr.decode!(delimited) )}} _ -> {:node, {:json_serialize_expr, PgQuery.JsonSerializeExpr.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_scalar_expr, previous_value} -> {:node, {:json_scalar_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JsonScalarExpr.decode!(delimited) )}} _ -> {:node, {:json_scalar_expr, PgQuery.JsonScalarExpr.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_parse_expr, previous_value} -> {:node, {:json_parse_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JsonParseExpr.decode!(delimited) )}} _ -> {:node, {:json_parse_expr, PgQuery.JsonParseExpr.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_key_value, previous_value} -> {:node, {:json_key_value, Protox.MergeMessage.merge( previous_value, PgQuery.JsonKeyValue.decode!(delimited) )}} _ -> {:node, {:json_key_value, PgQuery.JsonKeyValue.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_table_column, previous_value} -> {:node, {:json_table_column, Protox.MergeMessage.merge( previous_value, PgQuery.JsonTableColumn.decode!(delimited) )}} _ -> {:node, {:json_table_column, PgQuery.JsonTableColumn.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_table, previous_value} -> {:node, {:json_table, Protox.MergeMessage.merge( previous_value, PgQuery.JsonTable.decode!(delimited) )}} _ -> {:node, {:json_table, PgQuery.JsonTable.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_table_path_spec, previous_value} -> {:node, {:json_table_path_spec, Protox.MergeMessage.merge( previous_value, PgQuery.JsonTablePathSpec.decode!(delimited) )}} _ -> {:node, {:json_table_path_spec, PgQuery.JsonTablePathSpec.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_func_expr, previous_value} -> {:node, {:json_func_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JsonFuncExpr.decode!(delimited) )}} _ -> {:node, {:json_func_expr, PgQuery.JsonFuncExpr.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_argument, previous_value} -> {:node, {:json_argument, Protox.MergeMessage.merge( previous_value, PgQuery.JsonArgument.decode!(delimited) )}} _ -> {:node, {:json_argument, PgQuery.JsonArgument.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_output, previous_value} -> {:node, {:json_output, Protox.MergeMessage.merge( previous_value, PgQuery.JsonOutput.decode!(delimited) )}} _ -> {:node, {:json_output, PgQuery.JsonOutput.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:trigger_transition, previous_value} -> {:node, {:trigger_transition, Protox.MergeMessage.merge( previous_value, PgQuery.TriggerTransition.decode!(delimited) )}} _ -> {:node, {:trigger_transition, PgQuery.TriggerTransition.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:merge_when_clause, previous_value} -> {:node, {:merge_when_clause, Protox.MergeMessage.merge( previous_value, PgQuery.MergeWhenClause.decode!(delimited) )}} _ -> {:node, {:merge_when_clause, PgQuery.MergeWhenClause.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\a", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:common_table_expr, previous_value} -> {:node, {:common_table_expr, Protox.MergeMessage.merge( previous_value, PgQuery.CommonTableExpr.decode!(delimited) )}} _ -> {:node, {:common_table_expr, PgQuery.CommonTableExpr.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:ctecycle_clause, previous_value} -> {:node, {:ctecycle_clause, Protox.MergeMessage.merge( previous_value, PgQuery.CTECycleClause.decode!(delimited) )}} _ -> {:node, {:ctecycle_clause, PgQuery.CTECycleClause.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:ctesearch_clause, previous_value} -> {:node, {:ctesearch_clause, Protox.MergeMessage.merge( previous_value, PgQuery.CTESearchClause.decode!(delimited) )}} _ -> {:node, {:ctesearch_clause, PgQuery.CTESearchClause.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:on_conflict_clause, previous_value} -> {:node, {:on_conflict_clause, Protox.MergeMessage.merge( previous_value, PgQuery.OnConflictClause.decode!(delimited) )}} _ -> {:node, {:on_conflict_clause, PgQuery.OnConflictClause.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:infer_clause, previous_value} -> {:node, {:infer_clause, Protox.MergeMessage.merge( previous_value, PgQuery.InferClause.decode!(delimited) )}} _ -> {:node, {:infer_clause, PgQuery.InferClause.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:with_clause, previous_value} -> {:node, {:with_clause, Protox.MergeMessage.merge( previous_value, PgQuery.WithClause.decode!(delimited) )}} _ -> {:node, {:with_clause, PgQuery.WithClause.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:row_mark_clause, previous_value} -> {:node, {:row_mark_clause, Protox.MergeMessage.merge( previous_value, PgQuery.RowMarkClause.decode!(delimited) )}} _ -> {:node, {:row_mark_clause, PgQuery.RowMarkClause.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:window_clause, previous_value} -> {:node, {:window_clause, Protox.MergeMessage.merge( previous_value, PgQuery.WindowClause.decode!(delimited) )}} _ -> {:node, {:window_clause, PgQuery.WindowClause.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:grouping_set, previous_value} -> {:node, {:grouping_set, Protox.MergeMessage.merge( previous_value, PgQuery.GroupingSet.decode!(delimited) )}} _ -> {:node, {:grouping_set, PgQuery.GroupingSet.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:sort_group_clause, previous_value} -> {:node, {:sort_group_clause, Protox.MergeMessage.merge( previous_value, PgQuery.SortGroupClause.decode!(delimited) )}} _ -> {:node, {:sort_group_clause, PgQuery.SortGroupClause.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:with_check_option, previous_value} -> {:node, {:with_check_option, Protox.MergeMessage.merge( previous_value, PgQuery.WithCheckOption.decode!(delimited) )}} _ -> {:node, {:with_check_option, PgQuery.WithCheckOption.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:table_sample_clause, previous_value} -> {:node, {:table_sample_clause, Protox.MergeMessage.merge( previous_value, PgQuery.TableSampleClause.decode!(delimited) )}} _ -> {:node, {:table_sample_clause, PgQuery.TableSampleClause.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_tbl_function, previous_value} -> {:node, {:range_tbl_function, Protox.MergeMessage.merge( previous_value, PgQuery.RangeTblFunction.decode!(delimited) )}} _ -> {:node, {:range_tbl_function, PgQuery.RangeTblFunction.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:rtepermission_info, previous_value} -> {:node, {:rtepermission_info, Protox.MergeMessage.merge( previous_value, PgQuery.RTEPermissionInfo.decode!(delimited) )}} _ -> {:node, {:rtepermission_info, PgQuery.RTEPermissionInfo.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_tbl_entry, previous_value} -> {:node, {:range_tbl_entry, Protox.MergeMessage.merge( previous_value, PgQuery.RangeTblEntry.decode!(delimited) )}} _ -> {:node, {:range_tbl_entry, PgQuery.RangeTblEntry.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:partition_cmd, previous_value} -> {:node, {:partition_cmd, Protox.MergeMessage.merge( previous_value, PgQuery.PartitionCmd.decode!(delimited) )}} _ -> {:node, {:partition_cmd, PgQuery.PartitionCmd.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x06", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:single_partition_spec, previous_value} -> {:node, {:single_partition_spec, Protox.MergeMessage.merge( previous_value, PgQuery.SinglePartitionSpec.decode!(delimited) )}} _ -> {:node, {:single_partition_spec, PgQuery.SinglePartitionSpec.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:partition_range_datum, previous_value} -> {:node, {:partition_range_datum, Protox.MergeMessage.merge( previous_value, PgQuery.PartitionRangeDatum.decode!(delimited) )}} _ -> {:node, {:partition_range_datum, PgQuery.PartitionRangeDatum.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:partition_bound_spec, previous_value} -> {:node, {:partition_bound_spec, Protox.MergeMessage.merge( previous_value, PgQuery.PartitionBoundSpec.decode!(delimited) )}} _ -> {:node, {:partition_bound_spec, PgQuery.PartitionBoundSpec.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:partition_spec, previous_value} -> {:node, {:partition_spec, Protox.MergeMessage.merge( previous_value, PgQuery.PartitionSpec.decode!(delimited) )}} _ -> {:node, {:partition_spec, PgQuery.PartitionSpec.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:partition_elem, previous_value} -> {:node, {:partition_elem, Protox.MergeMessage.merge( previous_value, PgQuery.PartitionElem.decode!(delimited) )}} _ -> {:node, {:partition_elem, PgQuery.PartitionElem.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:xml_serialize, previous_value} -> {:node, {:xml_serialize, Protox.MergeMessage.merge( previous_value, PgQuery.XmlSerialize.decode!(delimited) )}} _ -> {:node, {:xml_serialize, PgQuery.XmlSerialize.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:locking_clause, previous_value} -> {:node, {:locking_clause, Protox.MergeMessage.merge( previous_value, PgQuery.LockingClause.decode!(delimited) )}} _ -> {:node, {:locking_clause, PgQuery.LockingClause.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:def_elem, previous_value} -> {:node, {:def_elem, Protox.MergeMessage.merge( previous_value, PgQuery.DefElem.decode!(delimited) )}} _ -> {:node, {:def_elem, PgQuery.DefElem.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:index_elem, previous_value} -> {:node, {:index_elem, Protox.MergeMessage.merge( previous_value, PgQuery.IndexElem.decode!(delimited) )}} _ -> {:node, {:index_elem, PgQuery.IndexElem.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:table_like_clause, previous_value} -> {:node, {:table_like_clause, Protox.MergeMessage.merge( previous_value, PgQuery.TableLikeClause.decode!(delimited) )}} _ -> {:node, {:table_like_clause, PgQuery.TableLikeClause.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:column_def, previous_value} -> {:node, {:column_def, Protox.MergeMessage.merge( previous_value, PgQuery.ColumnDef.decode!(delimited) )}} _ -> {:node, {:column_def, PgQuery.ColumnDef.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_table_sample, previous_value} -> {:node, {:range_table_sample, Protox.MergeMessage.merge( previous_value, PgQuery.RangeTableSample.decode!(delimited) )}} _ -> {:node, {:range_table_sample, PgQuery.RangeTableSample.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_table_func_col, previous_value} -> {:node, {:range_table_func_col, Protox.MergeMessage.merge( previous_value, PgQuery.RangeTableFuncCol.decode!(delimited) )}} _ -> {:node, {:range_table_func_col, PgQuery.RangeTableFuncCol.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_table_func, previous_value} -> {:node, {:range_table_func, Protox.MergeMessage.merge( previous_value, PgQuery.RangeTableFunc.decode!(delimited) )}} _ -> {:node, {:range_table_func, PgQuery.RangeTableFunc.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_function, previous_value} -> {:node, {:range_function, Protox.MergeMessage.merge( previous_value, PgQuery.RangeFunction.decode!(delimited) )}} _ -> {:node, {:range_function, PgQuery.RangeFunction.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_subselect, previous_value} -> {:node, {:range_subselect, Protox.MergeMessage.merge( previous_value, PgQuery.RangeSubselect.decode!(delimited) )}} _ -> {:node, {:range_subselect, PgQuery.RangeSubselect.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x05", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:window_def, previous_value} -> {:node, {:window_def, Protox.MergeMessage.merge( previous_value, PgQuery.WindowDef.decode!(delimited) )}} _ -> {:node, {:window_def, PgQuery.WindowDef.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:sort_by, previous_value} -> {:node, {:sort_by, Protox.MergeMessage.merge( previous_value, PgQuery.SortBy.decode!(delimited) )}} _ -> {:node, {:sort_by, PgQuery.SortBy.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:multi_assign_ref, previous_value} -> {:node, {:multi_assign_ref, Protox.MergeMessage.merge( previous_value, PgQuery.MultiAssignRef.decode!(delimited) )}} _ -> {:node, {:multi_assign_ref, PgQuery.MultiAssignRef.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:res_target, previous_value} -> {:node, {:res_target, Protox.MergeMessage.merge( previous_value, PgQuery.ResTarget.decode!(delimited) )}} _ -> {:node, {:res_target, PgQuery.ResTarget.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:a_array_expr, previous_value} -> {:node, {:a_array_expr, Protox.MergeMessage.merge( previous_value, PgQuery.A_ArrayExpr.decode!(delimited) )}} _ -> {:node, {:a_array_expr, PgQuery.A_ArrayExpr.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:a_indirection, previous_value} -> {:node, {:a_indirection, Protox.MergeMessage.merge( previous_value, PgQuery.A_Indirection.decode!(delimited) )}} _ -> {:node, {:a_indirection, PgQuery.A_Indirection.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:a_indices, previous_value} -> {:node, {:a_indices, Protox.MergeMessage.merge( previous_value, PgQuery.A_Indices.decode!(delimited) )}} _ -> {:node, {:a_indices, PgQuery.A_Indices.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:a_star, previous_value} -> {:node, {:a_star, Protox.MergeMessage.merge( previous_value, PgQuery.A_Star.decode!(delimited) )}} _ -> {:node, {:a_star, PgQuery.A_Star.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:func_call, previous_value} -> {:node, {:func_call, Protox.MergeMessage.merge( previous_value, PgQuery.FuncCall.decode!(delimited) )}} _ -> {:node, {:func_call, PgQuery.FuncCall.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:role_spec, previous_value} -> {:node, {:role_spec, Protox.MergeMessage.merge( previous_value, PgQuery.RoleSpec.decode!(delimited) )}} _ -> {:node, {:role_spec, PgQuery.RoleSpec.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:collate_clause, previous_value} -> {:node, {:collate_clause, Protox.MergeMessage.merge( previous_value, PgQuery.CollateClause.decode!(delimited) )}} _ -> {:node, {:collate_clause, PgQuery.CollateClause.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:type_cast, previous_value} -> {:node, {:type_cast, Protox.MergeMessage.merge( previous_value, PgQuery.TypeCast.decode!(delimited) )}} _ -> {:node, {:type_cast, PgQuery.TypeCast.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:a_expr, previous_value} -> {:node, {:a_expr, Protox.MergeMessage.merge( previous_value, PgQuery.A_Expr.decode!(delimited) )}} _ -> {:node, {:a_expr, PgQuery.A_Expr.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:param_ref, previous_value} -> {:node, {:param_ref, Protox.MergeMessage.merge( previous_value, PgQuery.ParamRef.decode!(delimited) )}} _ -> {:node, {:param_ref, PgQuery.ParamRef.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:column_ref, previous_value} -> {:node, {:column_ref, Protox.MergeMessage.merge( previous_value, PgQuery.ColumnRef.decode!(delimited) )}} _ -> {:node, {:column_ref, PgQuery.ColumnRef.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:type_name, previous_value} -> {:node, {:type_name, Protox.MergeMessage.merge( previous_value, PgQuery.TypeName.decode!(delimited) )}} _ -> {:node, {:type_name, PgQuery.TypeName.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x04", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:query, previous_value} -> {:node, {:query, Protox.MergeMessage.merge(previous_value, PgQuery.Query.decode!(delimited))}} _ -> {:node, {:query, PgQuery.Query.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:on_conflict_expr, previous_value} -> {:node, {:on_conflict_expr, Protox.MergeMessage.merge( previous_value, PgQuery.OnConflictExpr.decode!(delimited) )}} _ -> {:node, {:on_conflict_expr, PgQuery.OnConflictExpr.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:from_expr, previous_value} -> {:node, {:from_expr, Protox.MergeMessage.merge( previous_value, PgQuery.FromExpr.decode!(delimited) )}} _ -> {:node, {:from_expr, PgQuery.FromExpr.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:join_expr, previous_value} -> {:node, {:join_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JoinExpr.decode!(delimited) )}} _ -> {:node, {:join_expr, PgQuery.JoinExpr.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_tbl_ref, previous_value} -> {:node, {:range_tbl_ref, Protox.MergeMessage.merge( previous_value, PgQuery.RangeTblRef.decode!(delimited) )}} _ -> {:node, {:range_tbl_ref, PgQuery.RangeTblRef.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:target_entry, previous_value} -> {:node, {:target_entry, Protox.MergeMessage.merge( previous_value, PgQuery.TargetEntry.decode!(delimited) )}} _ -> {:node, {:target_entry, PgQuery.TargetEntry.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:inference_elem, previous_value} -> {:node, {:inference_elem, Protox.MergeMessage.merge( previous_value, PgQuery.InferenceElem.decode!(delimited) )}} _ -> {:node, {:inference_elem, PgQuery.InferenceElem.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:next_value_expr, previous_value} -> {:node, {:next_value_expr, Protox.MergeMessage.merge( previous_value, PgQuery.NextValueExpr.decode!(delimited) )}} _ -> {:node, {:next_value_expr, PgQuery.NextValueExpr.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:current_of_expr, previous_value} -> {:node, {:current_of_expr, Protox.MergeMessage.merge( previous_value, PgQuery.CurrentOfExpr.decode!(delimited) )}} _ -> {:node, {:current_of_expr, PgQuery.CurrentOfExpr.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:set_to_default, previous_value} -> {:node, {:set_to_default, Protox.MergeMessage.merge( previous_value, PgQuery.SetToDefault.decode!(delimited) )}} _ -> {:node, {:set_to_default, PgQuery.SetToDefault.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:coerce_to_domain_value, previous_value} -> {:node, {:coerce_to_domain_value, Protox.MergeMessage.merge( previous_value, PgQuery.CoerceToDomainValue.decode!(delimited) )}} _ -> {:node, {:coerce_to_domain_value, PgQuery.CoerceToDomainValue.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:coerce_to_domain, previous_value} -> {:node, {:coerce_to_domain, Protox.MergeMessage.merge( previous_value, PgQuery.CoerceToDomain.decode!(delimited) )}} _ -> {:node, {:coerce_to_domain, PgQuery.CoerceToDomain.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:merge_action, previous_value} -> {:node, {:merge_action, Protox.MergeMessage.merge( previous_value, PgQuery.MergeAction.decode!(delimited) )}} _ -> {:node, {:merge_action, PgQuery.MergeAction.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:boolean_test, previous_value} -> {:node, {:boolean_test, Protox.MergeMessage.merge( previous_value, PgQuery.BooleanTest.decode!(delimited) )}} _ -> {:node, {:boolean_test, PgQuery.BooleanTest.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:null_test, previous_value} -> {:node, {:null_test, Protox.MergeMessage.merge( previous_value, PgQuery.NullTest.decode!(delimited) )}} _ -> {:node, {:null_test, PgQuery.NullTest.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_table_sibling_join, previous_value} -> {:node, {:json_table_sibling_join, Protox.MergeMessage.merge( previous_value, PgQuery.JsonTableSiblingJoin.decode!(delimited) )}} _ -> {:node, {:json_table_sibling_join, PgQuery.JsonTableSiblingJoin.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x03", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_table_path_scan, previous_value} -> {:node, {:json_table_path_scan, Protox.MergeMessage.merge( previous_value, PgQuery.JsonTablePathScan.decode!(delimited) )}} _ -> {:node, {:json_table_path_scan, PgQuery.JsonTablePathScan.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_table_path, previous_value} -> {:node, {:json_table_path, Protox.MergeMessage.merge( previous_value, PgQuery.JsonTablePath.decode!(delimited) )}} _ -> {:node, {:json_table_path, PgQuery.JsonTablePath.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_expr, previous_value} -> {:node, {:json_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JsonExpr.decode!(delimited) )}} _ -> {:node, {:json_expr, PgQuery.JsonExpr.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_behavior, previous_value} -> {:node, {:json_behavior, Protox.MergeMessage.merge( previous_value, PgQuery.JsonBehavior.decode!(delimited) )}} _ -> {:node, {:json_behavior, PgQuery.JsonBehavior.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_is_predicate, previous_value} -> {:node, {:json_is_predicate, Protox.MergeMessage.merge( previous_value, PgQuery.JsonIsPredicate.decode!(delimited) )}} _ -> {:node, {:json_is_predicate, PgQuery.JsonIsPredicate.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_constructor_expr, previous_value} -> {:node, {:json_constructor_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JsonConstructorExpr.decode!(delimited) )}} _ -> {:node, {:json_constructor_expr, PgQuery.JsonConstructorExpr.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_value_expr, previous_value} -> {:node, {:json_value_expr, Protox.MergeMessage.merge( previous_value, PgQuery.JsonValueExpr.decode!(delimited) )}} _ -> {:node, {:json_value_expr, PgQuery.JsonValueExpr.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_returning, previous_value} -> {:node, {:json_returning, Protox.MergeMessage.merge( previous_value, PgQuery.JsonReturning.decode!(delimited) )}} _ -> {:node, {:json_returning, PgQuery.JsonReturning.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:json_format, previous_value} -> {:node, {:json_format, Protox.MergeMessage.merge( previous_value, PgQuery.JsonFormat.decode!(delimited) )}} _ -> {:node, {:json_format, PgQuery.JsonFormat.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:xml_expr, previous_value} -> {:node, {:xml_expr, Protox.MergeMessage.merge( previous_value, PgQuery.XmlExpr.decode!(delimited) )}} _ -> {:node, {:xml_expr, PgQuery.XmlExpr.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:sqlvalue_function, previous_value} -> {:node, {:sqlvalue_function, Protox.MergeMessage.merge( previous_value, PgQuery.SQLValueFunction.decode!(delimited) )}} _ -> {:node, {:sqlvalue_function, PgQuery.SQLValueFunction.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:min_max_expr, previous_value} -> {:node, {:min_max_expr, Protox.MergeMessage.merge( previous_value, PgQuery.MinMaxExpr.decode!(delimited) )}} _ -> {:node, {:min_max_expr, PgQuery.MinMaxExpr.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:coalesce_expr, previous_value} -> {:node, {:coalesce_expr, Protox.MergeMessage.merge( previous_value, PgQuery.CoalesceExpr.decode!(delimited) )}} _ -> {:node, {:coalesce_expr, PgQuery.CoalesceExpr.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:row_compare_expr, previous_value} -> {:node, {:row_compare_expr, Protox.MergeMessage.merge( previous_value, PgQuery.RowCompareExpr.decode!(delimited) )}} _ -> {:node, {:row_compare_expr, PgQuery.RowCompareExpr.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:row_expr, previous_value} -> {:node, {:row_expr, Protox.MergeMessage.merge( previous_value, PgQuery.RowExpr.decode!(delimited) )}} _ -> {:node, {:row_expr, PgQuery.RowExpr.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:array_expr, previous_value} -> {:node, {:array_expr, Protox.MergeMessage.merge( previous_value, PgQuery.ArrayExpr.decode!(delimited) )}} _ -> {:node, {:array_expr, PgQuery.ArrayExpr.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x02", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:case_test_expr, previous_value} -> {:node, {:case_test_expr, Protox.MergeMessage.merge( previous_value, PgQuery.CaseTestExpr.decode!(delimited) )}} _ -> {:node, {:case_test_expr, PgQuery.CaseTestExpr.decode!(delimited)}} end ], rest} <<31::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:case_when, previous_value} -> {:node, {:case_when, Protox.MergeMessage.merge( previous_value, PgQuery.CaseWhen.decode!(delimited) )}} _ -> {:node, {:case_when, PgQuery.CaseWhen.decode!(delimited)}} end ], rest} <<30::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:case_expr, previous_value} -> {:node, {:case_expr, Protox.MergeMessage.merge( previous_value, PgQuery.CaseExpr.decode!(delimited) )}} _ -> {:node, {:case_expr, PgQuery.CaseExpr.decode!(delimited)}} end ], rest} <<29::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:collate_expr, previous_value} -> {:node, {:collate_expr, Protox.MergeMessage.merge( previous_value, PgQuery.CollateExpr.decode!(delimited) )}} _ -> {:node, {:collate_expr, PgQuery.CollateExpr.decode!(delimited)}} end ], rest} <<28::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:convert_rowtype_expr, previous_value} -> {:node, {:convert_rowtype_expr, Protox.MergeMessage.merge( previous_value, PgQuery.ConvertRowtypeExpr.decode!(delimited) )}} _ -> {:node, {:convert_rowtype_expr, PgQuery.ConvertRowtypeExpr.decode!(delimited)}} end ], rest} <<27::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:array_coerce_expr, previous_value} -> {:node, {:array_coerce_expr, Protox.MergeMessage.merge( previous_value, PgQuery.ArrayCoerceExpr.decode!(delimited) )}} _ -> {:node, {:array_coerce_expr, PgQuery.ArrayCoerceExpr.decode!(delimited)}} end ], rest} <<26::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:coerce_via_io, previous_value} -> {:node, {:coerce_via_io, Protox.MergeMessage.merge( previous_value, PgQuery.CoerceViaIO.decode!(delimited) )}} _ -> {:node, {:coerce_via_io, PgQuery.CoerceViaIO.decode!(delimited)}} end ], rest} <<25::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:relabel_type, previous_value} -> {:node, {:relabel_type, Protox.MergeMessage.merge( previous_value, PgQuery.RelabelType.decode!(delimited) )}} _ -> {:node, {:relabel_type, PgQuery.RelabelType.decode!(delimited)}} end ], rest} <<24::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:field_store, previous_value} -> {:node, {:field_store, Protox.MergeMessage.merge( previous_value, PgQuery.FieldStore.decode!(delimited) )}} _ -> {:node, {:field_store, PgQuery.FieldStore.decode!(delimited)}} end ], rest} <<23::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:field_select, previous_value} -> {:node, {:field_select, Protox.MergeMessage.merge( previous_value, PgQuery.FieldSelect.decode!(delimited) )}} _ -> {:node, {:field_select, PgQuery.FieldSelect.decode!(delimited)}} end ], rest} <<22::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alternative_sub_plan, previous_value} -> {:node, {:alternative_sub_plan, Protox.MergeMessage.merge( previous_value, PgQuery.AlternativeSubPlan.decode!(delimited) )}} _ -> {:node, {:alternative_sub_plan, PgQuery.AlternativeSubPlan.decode!(delimited)}} end ], rest} <<21::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:sub_plan, previous_value} -> {:node, {:sub_plan, Protox.MergeMessage.merge( previous_value, PgQuery.SubPlan.decode!(delimited) )}} _ -> {:node, {:sub_plan, PgQuery.SubPlan.decode!(delimited)}} end ], rest} <<20::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:sub_link, previous_value} -> {:node, {:sub_link, Protox.MergeMessage.merge( previous_value, PgQuery.SubLink.decode!(delimited) )}} _ -> {:node, {:sub_link, PgQuery.SubLink.decode!(delimited)}} end ], rest} <<19::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:bool_expr, previous_value} -> {:node, {:bool_expr, Protox.MergeMessage.merge( previous_value, PgQuery.BoolExpr.decode!(delimited) )}} _ -> {:node, {:bool_expr, PgQuery.BoolExpr.decode!(delimited)}} end ], rest} <<18::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:scalar_array_op_expr, previous_value} -> {:node, {:scalar_array_op_expr, Protox.MergeMessage.merge( previous_value, PgQuery.ScalarArrayOpExpr.decode!(delimited) )}} _ -> {:node, {:scalar_array_op_expr, PgQuery.ScalarArrayOpExpr.decode!(delimited)}} end ], rest} <<17::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:null_if_expr, previous_value} -> {:node, {:null_if_expr, Protox.MergeMessage.merge( previous_value, PgQuery.NullIfExpr.decode!(delimited) )}} _ -> {:node, {:null_if_expr, PgQuery.NullIfExpr.decode!(delimited)}} end ], rest} <<16::5, _wire_type::3, "\x01", bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:distinct_expr, previous_value} -> {:node, {:distinct_expr, Protox.MergeMessage.merge( previous_value, PgQuery.DistinctExpr.decode!(delimited) )}} _ -> {:node, {:distinct_expr, PgQuery.DistinctExpr.decode!(delimited)}} end ], rest} <<15::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:op_expr, previous_value} -> {:node, {:op_expr, Protox.MergeMessage.merge( previous_value, PgQuery.OpExpr.decode!(delimited) )}} _ -> {:node, {:op_expr, PgQuery.OpExpr.decode!(delimited)}} end ], rest} <<14::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:named_arg_expr, previous_value} -> {:node, {:named_arg_expr, Protox.MergeMessage.merge( previous_value, PgQuery.NamedArgExpr.decode!(delimited) )}} _ -> {:node, {:named_arg_expr, PgQuery.NamedArgExpr.decode!(delimited)}} end ], rest} <<13::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:func_expr, previous_value} -> {:node, {:func_expr, Protox.MergeMessage.merge( previous_value, PgQuery.FuncExpr.decode!(delimited) )}} _ -> {:node, {:func_expr, PgQuery.FuncExpr.decode!(delimited)}} end ], rest} <<12::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:subscripting_ref, previous_value} -> {:node, {:subscripting_ref, Protox.MergeMessage.merge( previous_value, PgQuery.SubscriptingRef.decode!(delimited) )}} _ -> {:node, {:subscripting_ref, PgQuery.SubscriptingRef.decode!(delimited)}} end ], rest} <<11::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:merge_support_func, previous_value} -> {:node, {:merge_support_func, Protox.MergeMessage.merge( previous_value, PgQuery.MergeSupportFunc.decode!(delimited) )}} _ -> {:node, {:merge_support_func, PgQuery.MergeSupportFunc.decode!(delimited)}} end ], rest} <<10::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:window_func_run_condition, previous_value} -> {:node, {:window_func_run_condition, Protox.MergeMessage.merge( previous_value, PgQuery.WindowFuncRunCondition.decode!(delimited) )}} _ -> {:node, {:window_func_run_condition, PgQuery.WindowFuncRunCondition.decode!(delimited)}} end ], rest} <<9::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:window_func, previous_value} -> {:node, {:window_func, Protox.MergeMessage.merge( previous_value, PgQuery.WindowFunc.decode!(delimited) )}} _ -> {:node, {:window_func, PgQuery.WindowFunc.decode!(delimited)}} end ], rest} <<8::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:grouping_func, previous_value} -> {:node, {:grouping_func, Protox.MergeMessage.merge( previous_value, PgQuery.GroupingFunc.decode!(delimited) )}} _ -> {:node, {:grouping_func, PgQuery.GroupingFunc.decode!(delimited)}} end ], rest} <<7::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:aggref, previous_value} -> {:node, {:aggref, Protox.MergeMessage.merge( previous_value, PgQuery.Aggref.decode!(delimited) )}} _ -> {:node, {:aggref, PgQuery.Aggref.decode!(delimited)}} end ], rest} <<6::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:param, previous_value} -> {:node, {:param, Protox.MergeMessage.merge(previous_value, PgQuery.Param.decode!(delimited))}} _ -> {:node, {:param, PgQuery.Param.decode!(delimited)}} end ], rest} <<5::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:var, previous_value} -> {:node, {:var, Protox.MergeMessage.merge(previous_value, PgQuery.Var.decode!(delimited))}} _ -> {:node, {:var, PgQuery.Var.decode!(delimited)}} end ], rest} <<4::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:into_clause, previous_value} -> {:node, {:into_clause, Protox.MergeMessage.merge( previous_value, PgQuery.IntoClause.decode!(delimited) )}} _ -> {:node, {:into_clause, PgQuery.IntoClause.decode!(delimited)}} end ], rest} <<3::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:table_func, previous_value} -> {:node, {:table_func, Protox.MergeMessage.merge( previous_value, PgQuery.TableFunc.decode!(delimited) )}} _ -> {:node, {:table_func, PgQuery.TableFunc.decode!(delimited)}} end ], rest} <<2::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:range_var, previous_value} -> {:node, {:range_var, Protox.MergeMessage.merge( previous_value, PgQuery.RangeVar.decode!(delimited) )}} _ -> {:node, {:range_var, PgQuery.RangeVar.decode!(delimited)}} end ], rest} <<1::5, _wire_type::3, bytes::binary>> -> {len, bytes} = Protox.Varint.decode(bytes) {delimited, rest} = Protox.Decode.parse_delimited(bytes, len) {[ case msg.node do {:alias, previous_value} -> {:node, {:alias, Protox.MergeMessage.merge(previous_value, PgQuery.Alias.decode!(delimited))}} _ -> {:node, {:alias, PgQuery.Alias.decode!(delimited)}} end ], rest} <> -> {tag, wire_type, rest} = Protox.Decode.parse_key(bytes) {value, rest} = Protox.Decode.parse_unknown(tag, wire_type, rest) {[__uf__: msg.__uf__ ++ [value]], rest} end msg_updated = struct(msg, field) parse_key_value(rest, msg_updated) end ) ) ( @spec unknown_fields(struct()) :: [{non_neg_integer(), Protox.Types.tag(), binary()}] def unknown_fields(msg) do msg.__uf__ end @spec unknown_fields_name() :: :__uf__ def unknown_fields_name() do :__uf__ end @spec clear_unknown_fields(struct) :: struct def clear_unknown_fields(msg) do struct!(msg, __uf__: []) end ) ( @spec default(atom()) :: {:ok, boolean() | integer() | String.t() | float()} | {:error, :no_such_field | :no_default_value} def default(:a_const) do {:error, :no_default_value} end def default(:oid_list) do {:error, :no_default_value} end def default(:int_list) do {:error, :no_default_value} end def default(:list) do {:error, :no_default_value} end def default(:bit_string) do {:error, :no_default_value} end def default(:string) do {:error, :no_default_value} end def default(:boolean) do {:error, :no_default_value} end def default(:float) do {:error, :no_default_value} end def default(:integer) do {:error, :no_default_value} end def default(:drop_subscription_stmt) do {:error, :no_default_value} end def default(:alter_subscription_stmt) do {:error, :no_default_value} end def default(:create_subscription_stmt) do {:error, :no_default_value} end def default(:alter_publication_stmt) do {:error, :no_default_value} end def default(:create_publication_stmt) do {:error, :no_default_value} end def default(:publication_obj_spec) do {:error, :no_default_value} end def default(:publication_table) do {:error, :no_default_value} end def default(:alter_tsconfiguration_stmt) do {:error, :no_default_value} end def default(:alter_tsdictionary_stmt) do {:error, :no_default_value} end def default(:reassign_owned_stmt) do {:error, :no_default_value} end def default(:drop_owned_stmt) do {:error, :no_default_value} end def default(:deallocate_stmt) do {:error, :no_default_value} end def default(:execute_stmt) do {:error, :no_default_value} end def default(:prepare_stmt) do {:error, :no_default_value} end def default(:create_transform_stmt) do {:error, :no_default_value} end def default(:create_cast_stmt) do {:error, :no_default_value} end def default(:create_conversion_stmt) do {:error, :no_default_value} end def default(:reindex_stmt) do {:error, :no_default_value} end def default(:constraints_set_stmt) do {:error, :no_default_value} end def default(:lock_stmt) do {:error, :no_default_value} end def default(:discard_stmt) do {:error, :no_default_value} end def default(:check_point_stmt) do {:error, :no_default_value} end def default(:refresh_mat_view_stmt) do {:error, :no_default_value} end def default(:create_table_as_stmt) do {:error, :no_default_value} end def default(:explain_stmt) do {:error, :no_default_value} end def default(:vacuum_relation) do {:error, :no_default_value} end def default(:vacuum_stmt) do {:error, :no_default_value} end def default(:cluster_stmt) do {:error, :no_default_value} end def default(:alter_system_stmt) do {:error, :no_default_value} end def default(:dropdb_stmt) do {:error, :no_default_value} end def default(:alter_database_set_stmt) do {:error, :no_default_value} end def default(:alter_database_refresh_coll_stmt) do {:error, :no_default_value} end def default(:alter_database_stmt) do {:error, :no_default_value} end def default(:createdb_stmt) do {:error, :no_default_value} end def default(:load_stmt) do {:error, :no_default_value} end def default(:view_stmt) do {:error, :no_default_value} end def default(:alter_enum_stmt) do {:error, :no_default_value} end def default(:create_range_stmt) do {:error, :no_default_value} end def default(:create_enum_stmt) do {:error, :no_default_value} end def default(:composite_type_stmt) do {:error, :no_default_value} end def default(:transaction_stmt) do {:error, :no_default_value} end def default(:unlisten_stmt) do {:error, :no_default_value} end def default(:listen_stmt) do {:error, :no_default_value} end def default(:notify_stmt) do {:error, :no_default_value} end def default(:rule_stmt) do {:error, :no_default_value} end def default(:alter_type_stmt) do {:error, :no_default_value} end def default(:alter_operator_stmt) do {:error, :no_default_value} end def default(:alter_owner_stmt) do {:error, :no_default_value} end def default(:alter_object_schema_stmt) do {:error, :no_default_value} end def default(:alter_object_depends_stmt) do {:error, :no_default_value} end def default(:rename_stmt) do {:error, :no_default_value} end def default(:call_context) do {:error, :no_default_value} end def default(:call_stmt) do {:error, :no_default_value} end def default(:inline_code_block) do {:error, :no_default_value} end def default(:do_stmt) do {:error, :no_default_value} end def default(:alter_function_stmt) do {:error, :no_default_value} end def default(:function_parameter) do {:error, :no_default_value} end def default(:create_function_stmt) do {:error, :no_default_value} end def default(:alter_stats_stmt) do {:error, :no_default_value} end def default(:stats_elem) do {:error, :no_default_value} end def default(:create_stats_stmt) do {:error, :no_default_value} end def default(:index_stmt) do {:error, :no_default_value} end def default(:fetch_stmt) do {:error, :no_default_value} end def default(:close_portal_stmt) do {:error, :no_default_value} end def default(:declare_cursor_stmt) do {:error, :no_default_value} end def default(:sec_label_stmt) do {:error, :no_default_value} end def default(:comment_stmt) do {:error, :no_default_value} end def default(:truncate_stmt) do {:error, :no_default_value} end def default(:drop_stmt) do {:error, :no_default_value} end def default(:alter_op_family_stmt) do {:error, :no_default_value} end def default(:create_op_family_stmt) do {:error, :no_default_value} end def default(:create_op_class_item) do {:error, :no_default_value} end def default(:create_op_class_stmt) do {:error, :no_default_value} end def default(:create_domain_stmt) do {:error, :no_default_value} end def default(:define_stmt) do {:error, :no_default_value} end def default(:alter_seq_stmt) do {:error, :no_default_value} end def default(:create_seq_stmt) do {:error, :no_default_value} end def default(:drop_role_stmt) do {:error, :no_default_value} end def default(:alter_role_set_stmt) do {:error, :no_default_value} end def default(:alter_role_stmt) do {:error, :no_default_value} end def default(:create_role_stmt) do {:error, :no_default_value} end def default(:create_plang_stmt) do {:error, :no_default_value} end def default(:alter_event_trig_stmt) do {:error, :no_default_value} end def default(:create_event_trig_stmt) do {:error, :no_default_value} end def default(:create_trig_stmt) do {:error, :no_default_value} end def default(:create_am_stmt) do {:error, :no_default_value} end def default(:alter_policy_stmt) do {:error, :no_default_value} end def default(:create_policy_stmt) do {:error, :no_default_value} end def default(:import_foreign_schema_stmt) do {:error, :no_default_value} end def default(:drop_user_mapping_stmt) do {:error, :no_default_value} end def default(:alter_user_mapping_stmt) do {:error, :no_default_value} end def default(:create_user_mapping_stmt) do {:error, :no_default_value} end def default(:create_foreign_table_stmt) do {:error, :no_default_value} end def default(:alter_foreign_server_stmt) do {:error, :no_default_value} end def default(:create_foreign_server_stmt) do {:error, :no_default_value} end def default(:alter_fdw_stmt) do {:error, :no_default_value} end def default(:create_fdw_stmt) do {:error, :no_default_value} end def default(:alter_extension_contents_stmt) do {:error, :no_default_value} end def default(:alter_extension_stmt) do {:error, :no_default_value} end def default(:create_extension_stmt) do {:error, :no_default_value} end def default(:alter_table_move_all_stmt) do {:error, :no_default_value} end def default(:alter_table_space_options_stmt) do {:error, :no_default_value} end def default(:drop_table_space_stmt) do {:error, :no_default_value} end def default(:create_table_space_stmt) do {:error, :no_default_value} end def default(:constraint) do {:error, :no_default_value} end def default(:create_stmt) do {:error, :no_default_value} end def default(:variable_show_stmt) do {:error, :no_default_value} end def default(:variable_set_stmt) do {:error, :no_default_value} end def default(:copy_stmt) do {:error, :no_default_value} end def default(:alter_default_privileges_stmt) do {:error, :no_default_value} end def default(:grant_role_stmt) do {:error, :no_default_value} end def default(:access_priv) do {:error, :no_default_value} end def default(:object_with_args) do {:error, :no_default_value} end def default(:grant_stmt) do {:error, :no_default_value} end def default(:alter_domain_stmt) do {:error, :no_default_value} end def default(:alter_collation_stmt) do {:error, :no_default_value} end def default(:alter_table_cmd) do {:error, :no_default_value} end def default(:replica_identity_stmt) do {:error, :no_default_value} end def default(:alter_table_stmt) do {:error, :no_default_value} end def default(:create_schema_stmt) do {:error, :no_default_value} end def default(:plassign_stmt) do {:error, :no_default_value} end def default(:return_stmt) do {:error, :no_default_value} end def default(:set_operation_stmt) do {:error, :no_default_value} end def default(:select_stmt) do {:error, :no_default_value} end def default(:merge_stmt) do {:error, :no_default_value} end def default(:update_stmt) do {:error, :no_default_value} end def default(:delete_stmt) do {:error, :no_default_value} end def default(:insert_stmt) do {:error, :no_default_value} end def default(:raw_stmt) do {:error, :no_default_value} end def default(:json_array_agg) do {:error, :no_default_value} end def default(:json_object_agg) do {:error, :no_default_value} end def default(:json_agg_constructor) do {:error, :no_default_value} end def default(:json_array_query_constructor) do {:error, :no_default_value} end def default(:json_array_constructor) do {:error, :no_default_value} end def default(:json_object_constructor) do {:error, :no_default_value} end def default(:json_serialize_expr) do {:error, :no_default_value} end def default(:json_scalar_expr) do {:error, :no_default_value} end def default(:json_parse_expr) do {:error, :no_default_value} end def default(:json_key_value) do {:error, :no_default_value} end def default(:json_table_column) do {:error, :no_default_value} end def default(:json_table) do {:error, :no_default_value} end def default(:json_table_path_spec) do {:error, :no_default_value} end def default(:json_func_expr) do {:error, :no_default_value} end def default(:json_argument) do {:error, :no_default_value} end def default(:json_output) do {:error, :no_default_value} end def default(:trigger_transition) do {:error, :no_default_value} end def default(:merge_when_clause) do {:error, :no_default_value} end def default(:common_table_expr) do {:error, :no_default_value} end def default(:ctecycle_clause) do {:error, :no_default_value} end def default(:ctesearch_clause) do {:error, :no_default_value} end def default(:on_conflict_clause) do {:error, :no_default_value} end def default(:infer_clause) do {:error, :no_default_value} end def default(:with_clause) do {:error, :no_default_value} end def default(:row_mark_clause) do {:error, :no_default_value} end def default(:window_clause) do {:error, :no_default_value} end def default(:grouping_set) do {:error, :no_default_value} end def default(:sort_group_clause) do {:error, :no_default_value} end def default(:with_check_option) do {:error, :no_default_value} end def default(:table_sample_clause) do {:error, :no_default_value} end def default(:range_tbl_function) do {:error, :no_default_value} end def default(:rtepermission_info) do {:error, :no_default_value} end def default(:range_tbl_entry) do {:error, :no_default_value} end def default(:partition_cmd) do {:error, :no_default_value} end def default(:single_partition_spec) do {:error, :no_default_value} end def default(:partition_range_datum) do {:error, :no_default_value} end def default(:partition_bound_spec) do {:error, :no_default_value} end def default(:partition_spec) do {:error, :no_default_value} end def default(:partition_elem) do {:error, :no_default_value} end def default(:xml_serialize) do {:error, :no_default_value} end def default(:locking_clause) do {:error, :no_default_value} end def default(:def_elem) do {:error, :no_default_value} end def default(:index_elem) do {:error, :no_default_value} end def default(:table_like_clause) do {:error, :no_default_value} end def default(:column_def) do {:error, :no_default_value} end def default(:range_table_sample) do {:error, :no_default_value} end def default(:range_table_func_col) do {:error, :no_default_value} end def default(:range_table_func) do {:error, :no_default_value} end def default(:range_function) do {:error, :no_default_value} end def default(:range_subselect) do {:error, :no_default_value} end def default(:window_def) do {:error, :no_default_value} end def default(:sort_by) do {:error, :no_default_value} end def default(:multi_assign_ref) do {:error, :no_default_value} end def default(:res_target) do {:error, :no_default_value} end def default(:a_array_expr) do {:error, :no_default_value} end def default(:a_indirection) do {:error, :no_default_value} end def default(:a_indices) do {:error, :no_default_value} end def default(:a_star) do {:error, :no_default_value} end def default(:func_call) do {:error, :no_default_value} end def default(:role_spec) do {:error, :no_default_value} end def default(:collate_clause) do {:error, :no_default_value} end def default(:type_cast) do {:error, :no_default_value} end def default(:a_expr) do {:error, :no_default_value} end def default(:param_ref) do {:error, :no_default_value} end def default(:column_ref) do {:error, :no_default_value} end def default(:type_name) do {:error, :no_default_value} end def default(:query) do {:error, :no_default_value} end def default(:on_conflict_expr) do {:error, :no_default_value} end def default(:from_expr) do {:error, :no_default_value} end def default(:join_expr) do {:error, :no_default_value} end def default(:range_tbl_ref) do {:error, :no_default_value} end def default(:target_entry) do {:error, :no_default_value} end def default(:inference_elem) do {:error, :no_default_value} end def default(:next_value_expr) do {:error, :no_default_value} end def default(:current_of_expr) do {:error, :no_default_value} end def default(:set_to_default) do {:error, :no_default_value} end def default(:coerce_to_domain_value) do {:error, :no_default_value} end def default(:coerce_to_domain) do {:error, :no_default_value} end def default(:merge_action) do {:error, :no_default_value} end def default(:boolean_test) do {:error, :no_default_value} end def default(:null_test) do {:error, :no_default_value} end def default(:json_table_sibling_join) do {:error, :no_default_value} end def default(:json_table_path_scan) do {:error, :no_default_value} end def default(:json_table_path) do {:error, :no_default_value} end def default(:json_expr) do {:error, :no_default_value} end def default(:json_behavior) do {:error, :no_default_value} end def default(:json_is_predicate) do {:error, :no_default_value} end def default(:json_constructor_expr) do {:error, :no_default_value} end def default(:json_value_expr) do {:error, :no_default_value} end def default(:json_returning) do {:error, :no_default_value} end def default(:json_format) do {:error, :no_default_value} end def default(:xml_expr) do {:error, :no_default_value} end def default(:sqlvalue_function) do {:error, :no_default_value} end def default(:min_max_expr) do {:error, :no_default_value} end def default(:coalesce_expr) do {:error, :no_default_value} end def default(:row_compare_expr) do {:error, :no_default_value} end def default(:row_expr) do {:error, :no_default_value} end def default(:array_expr) do {:error, :no_default_value} end def default(:case_test_expr) do {:error, :no_default_value} end def default(:case_when) do {:error, :no_default_value} end def default(:case_expr) do {:error, :no_default_value} end def default(:collate_expr) do {:error, :no_default_value} end def default(:convert_rowtype_expr) do {:error, :no_default_value} end def default(:array_coerce_expr) do {:error, :no_default_value} end def default(:coerce_via_io) do {:error, :no_default_value} end def default(:relabel_type) do {:error, :no_default_value} end def default(:field_store) do {:error, :no_default_value} end def default(:field_select) do {:error, :no_default_value} end def default(:alternative_sub_plan) do {:error, :no_default_value} end def default(:sub_plan) do {:error, :no_default_value} end def default(:sub_link) do {:error, :no_default_value} end def default(:bool_expr) do {:error, :no_default_value} end def default(:scalar_array_op_expr) do {:error, :no_default_value} end def default(:null_if_expr) do {:error, :no_default_value} end def default(:distinct_expr) do {:error, :no_default_value} end def default(:op_expr) do {:error, :no_default_value} end def default(:named_arg_expr) do {:error, :no_default_value} end def default(:func_expr) do {:error, :no_default_value} end def default(:subscripting_ref) do {:error, :no_default_value} end def default(:merge_support_func) do {:error, :no_default_value} end def default(:window_func_run_condition) do {:error, :no_default_value} end def default(:window_func) do {:error, :no_default_value} end def default(:grouping_func) do {:error, :no_default_value} end def default(:aggref) do {:error, :no_default_value} end def default(:param) do {:error, :no_default_value} end def default(:var) do {:error, :no_default_value} end def default(:into_clause) do {:error, :no_default_value} end def default(:table_func) do {:error, :no_default_value} end def default(:range_var) do {:error, :no_default_value} end def default(:alias) do {:error, :no_default_value} end def default(_) do {:error, :no_such_field} end ) @spec schema() :: Protox.MessageSchema.t() def schema() do %{ __struct__: Protox.MessageSchema, fields: %{ a_array_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :a_array_expr, tag: 76, type: {:message, PgQuery.A_ArrayExpr} }, a_const: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :a_const, tag: 268, type: {:message, PgQuery.A_Const} }, a_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :a_expr, tag: 68, type: {:message, PgQuery.A_Expr} }, a_indices: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :a_indices, tag: 74, type: {:message, PgQuery.A_Indices} }, a_indirection: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :a_indirection, tag: 75, type: {:message, PgQuery.A_Indirection} }, a_star: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :a_star, tag: 73, type: {:message, PgQuery.A_Star} }, access_priv: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :access_priv, tag: 148, type: {:message, PgQuery.AccessPriv} }, aggref: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :aggref, tag: 7, type: {:message, PgQuery.Aggref} }, alias: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alias, tag: 1, type: {:message, PgQuery.Alias} }, alter_collation_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_collation_stmt, tag: 144, type: {:message, PgQuery.AlterCollationStmt} }, alter_database_refresh_coll_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_database_refresh_coll_stmt, tag: 228, type: {:message, PgQuery.AlterDatabaseRefreshCollStmt} }, alter_database_set_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_database_set_stmt, tag: 229, type: {:message, PgQuery.AlterDatabaseSetStmt} }, alter_database_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_database_stmt, tag: 227, type: {:message, PgQuery.AlterDatabaseStmt} }, alter_default_privileges_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_default_privileges_stmt, tag: 150, type: {:message, PgQuery.AlterDefaultPrivilegesStmt} }, alter_domain_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_domain_stmt, tag: 145, type: {:message, PgQuery.AlterDomainStmt} }, alter_enum_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_enum_stmt, tag: 223, type: {:message, PgQuery.AlterEnumStmt} }, alter_event_trig_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_event_trig_stmt, tag: 177, type: {:message, PgQuery.AlterEventTrigStmt} }, alter_extension_contents_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_extension_contents_stmt, tag: 162, type: {:message, PgQuery.AlterExtensionContentsStmt} }, alter_extension_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_extension_stmt, tag: 161, type: {:message, PgQuery.AlterExtensionStmt} }, alter_fdw_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_fdw_stmt, tag: 164, type: {:message, PgQuery.AlterFdwStmt} }, alter_foreign_server_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_foreign_server_stmt, tag: 166, type: {:message, PgQuery.AlterForeignServerStmt} }, alter_function_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_function_stmt, tag: 204, type: {:message, PgQuery.AlterFunctionStmt} }, alter_object_depends_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_object_depends_stmt, tag: 210, type: {:message, PgQuery.AlterObjectDependsStmt} }, alter_object_schema_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_object_schema_stmt, tag: 211, type: {:message, PgQuery.AlterObjectSchemaStmt} }, alter_op_family_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_op_family_stmt, tag: 190, type: {:message, PgQuery.AlterOpFamilyStmt} }, alter_operator_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_operator_stmt, tag: 213, type: {:message, PgQuery.AlterOperatorStmt} }, alter_owner_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_owner_stmt, tag: 212, type: {:message, PgQuery.AlterOwnerStmt} }, alter_policy_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_policy_stmt, tag: 173, type: {:message, PgQuery.AlterPolicyStmt} }, alter_publication_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_publication_stmt, tag: 256, type: {:message, PgQuery.AlterPublicationStmt} }, alter_role_set_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_role_set_stmt, tag: 181, type: {:message, PgQuery.AlterRoleSetStmt} }, alter_role_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_role_stmt, tag: 180, type: {:message, PgQuery.AlterRoleStmt} }, alter_seq_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_seq_stmt, tag: 184, type: {:message, PgQuery.AlterSeqStmt} }, alter_stats_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_stats_stmt, tag: 201, type: {:message, PgQuery.AlterStatsStmt} }, alter_subscription_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_subscription_stmt, tag: 258, type: {:message, PgQuery.AlterSubscriptionStmt} }, alter_system_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_system_stmt, tag: 231, type: {:message, PgQuery.AlterSystemStmt} }, alter_table_cmd: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_table_cmd, tag: 143, type: {:message, PgQuery.AlterTableCmd} }, alter_table_move_all_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_table_move_all_stmt, tag: 159, type: {:message, PgQuery.AlterTableMoveAllStmt} }, alter_table_space_options_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_table_space_options_stmt, tag: 158, type: {:message, PgQuery.AlterTableSpaceOptionsStmt} }, alter_table_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_table_stmt, tag: 141, type: {:message, PgQuery.AlterTableStmt} }, alter_tsconfiguration_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_tsconfiguration_stmt, tag: 252, type: {:message, PgQuery.AlterTSConfigurationStmt} }, alter_tsdictionary_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_tsdictionary_stmt, tag: 251, type: {:message, PgQuery.AlterTSDictionaryStmt} }, alter_type_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_type_stmt, tag: 214, type: {:message, PgQuery.AlterTypeStmt} }, alter_user_mapping_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alter_user_mapping_stmt, tag: 169, type: {:message, PgQuery.AlterUserMappingStmt} }, alternative_sub_plan: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :alternative_sub_plan, tag: 22, type: {:message, PgQuery.AlternativeSubPlan} }, array_coerce_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :array_coerce_expr, tag: 27, type: {:message, PgQuery.ArrayCoerceExpr} }, array_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :array_expr, tag: 33, type: {:message, PgQuery.ArrayExpr} }, bit_string: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :bit_string, tag: 264, type: {:message, PgQuery.BitString} }, bool_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :bool_expr, tag: 19, type: {:message, PgQuery.BoolExpr} }, boolean: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :boolean, tag: 262, type: {:message, PgQuery.Boolean} }, boolean_test: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :boolean_test, tag: 51, type: {:message, PgQuery.BooleanTest} }, call_context: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :call_context, tag: 208, type: {:message, PgQuery.CallContext} }, call_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :call_stmt, tag: 207, type: {:message, PgQuery.CallStmt} }, case_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :case_expr, tag: 30, type: {:message, PgQuery.CaseExpr} }, case_test_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :case_test_expr, tag: 32, type: {:message, PgQuery.CaseTestExpr} }, case_when: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :case_when, tag: 31, type: {:message, PgQuery.CaseWhen} }, check_point_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :check_point_stmt, tag: 238, type: {:message, PgQuery.CheckPointStmt} }, close_portal_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :close_portal_stmt, tag: 196, type: {:message, PgQuery.ClosePortalStmt} }, cluster_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :cluster_stmt, tag: 232, type: {:message, PgQuery.ClusterStmt} }, coalesce_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :coalesce_expr, tag: 36, type: {:message, PgQuery.CoalesceExpr} }, coerce_to_domain: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :coerce_to_domain, tag: 53, type: {:message, PgQuery.CoerceToDomain} }, coerce_to_domain_value: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :coerce_to_domain_value, tag: 54, type: {:message, PgQuery.CoerceToDomainValue} }, coerce_via_io: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :coerce_via_io, tag: 26, type: {:message, PgQuery.CoerceViaIO} }, collate_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :collate_clause, tag: 70, type: {:message, PgQuery.CollateClause} }, collate_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :collate_expr, tag: 29, type: {:message, PgQuery.CollateExpr} }, column_def: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :column_def, tag: 86, type: {:message, PgQuery.ColumnDef} }, column_ref: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :column_ref, tag: 66, type: {:message, PgQuery.ColumnRef} }, comment_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :comment_stmt, tag: 193, type: {:message, PgQuery.CommentStmt} }, common_table_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :common_table_expr, tag: 112, type: {:message, PgQuery.CommonTableExpr} }, composite_type_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :composite_type_stmt, tag: 220, type: {:message, PgQuery.CompositeTypeStmt} }, constraint: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :constraint, tag: 155, type: {:message, PgQuery.Constraint} }, constraints_set_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :constraints_set_stmt, tag: 241, type: {:message, PgQuery.ConstraintsSetStmt} }, convert_rowtype_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :convert_rowtype_expr, tag: 28, type: {:message, PgQuery.ConvertRowtypeExpr} }, copy_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :copy_stmt, tag: 151, type: {:message, PgQuery.CopyStmt} }, create_am_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_am_stmt, tag: 174, type: {:message, PgQuery.CreateAmStmt} }, create_cast_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_cast_stmt, tag: 244, type: {:message, PgQuery.CreateCastStmt} }, create_conversion_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_conversion_stmt, tag: 243, type: {:message, PgQuery.CreateConversionStmt} }, create_domain_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_domain_stmt, tag: 186, type: {:message, PgQuery.CreateDomainStmt} }, create_enum_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_enum_stmt, tag: 221, type: {:message, PgQuery.CreateEnumStmt} }, create_event_trig_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_event_trig_stmt, tag: 176, type: {:message, PgQuery.CreateEventTrigStmt} }, create_extension_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_extension_stmt, tag: 160, type: {:message, PgQuery.CreateExtensionStmt} }, create_fdw_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_fdw_stmt, tag: 163, type: {:message, PgQuery.CreateFdwStmt} }, create_foreign_server_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_foreign_server_stmt, tag: 165, type: {:message, PgQuery.CreateForeignServerStmt} }, create_foreign_table_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_foreign_table_stmt, tag: 167, type: {:message, PgQuery.CreateForeignTableStmt} }, create_function_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_function_stmt, tag: 202, type: {:message, PgQuery.CreateFunctionStmt} }, create_op_class_item: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_op_class_item, tag: 188, type: {:message, PgQuery.CreateOpClassItem} }, create_op_class_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_op_class_stmt, tag: 187, type: {:message, PgQuery.CreateOpClassStmt} }, create_op_family_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_op_family_stmt, tag: 189, type: {:message, PgQuery.CreateOpFamilyStmt} }, create_plang_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_plang_stmt, tag: 178, type: {:message, PgQuery.CreatePLangStmt} }, create_policy_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_policy_stmt, tag: 172, type: {:message, PgQuery.CreatePolicyStmt} }, create_publication_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_publication_stmt, tag: 255, type: {:message, PgQuery.CreatePublicationStmt} }, create_range_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_range_stmt, tag: 222, type: {:message, PgQuery.CreateRangeStmt} }, create_role_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_role_stmt, tag: 179, type: {:message, PgQuery.CreateRoleStmt} }, create_schema_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_schema_stmt, tag: 140, type: {:message, PgQuery.CreateSchemaStmt} }, create_seq_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_seq_stmt, tag: 183, type: {:message, PgQuery.CreateSeqStmt} }, create_stats_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_stats_stmt, tag: 199, type: {:message, PgQuery.CreateStatsStmt} }, create_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_stmt, tag: 154, type: {:message, PgQuery.CreateStmt} }, create_subscription_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_subscription_stmt, tag: 257, type: {:message, PgQuery.CreateSubscriptionStmt} }, create_table_as_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_table_as_stmt, tag: 236, type: {:message, PgQuery.CreateTableAsStmt} }, create_table_space_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_table_space_stmt, tag: 156, type: {:message, PgQuery.CreateTableSpaceStmt} }, create_transform_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_transform_stmt, tag: 245, type: {:message, PgQuery.CreateTransformStmt} }, create_trig_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_trig_stmt, tag: 175, type: {:message, PgQuery.CreateTrigStmt} }, create_user_mapping_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :create_user_mapping_stmt, tag: 168, type: {:message, PgQuery.CreateUserMappingStmt} }, createdb_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :createdb_stmt, tag: 226, type: {:message, PgQuery.CreatedbStmt} }, ctecycle_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :ctecycle_clause, tag: 111, type: {:message, PgQuery.CTECycleClause} }, ctesearch_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :ctesearch_clause, tag: 110, type: {:message, PgQuery.CTESearchClause} }, current_of_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :current_of_expr, tag: 56, type: {:message, PgQuery.CurrentOfExpr} }, deallocate_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :deallocate_stmt, tag: 248, type: {:message, PgQuery.DeallocateStmt} }, declare_cursor_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :declare_cursor_stmt, tag: 195, type: {:message, PgQuery.DeclareCursorStmt} }, def_elem: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :def_elem, tag: 89, type: {:message, PgQuery.DefElem} }, define_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :define_stmt, tag: 185, type: {:message, PgQuery.DefineStmt} }, delete_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :delete_stmt, tag: 133, type: {:message, PgQuery.DeleteStmt} }, discard_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :discard_stmt, tag: 239, type: {:message, PgQuery.DiscardStmt} }, distinct_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :distinct_expr, tag: 16, type: {:message, PgQuery.DistinctExpr} }, do_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :do_stmt, tag: 205, type: {:message, PgQuery.DoStmt} }, drop_owned_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :drop_owned_stmt, tag: 249, type: {:message, PgQuery.DropOwnedStmt} }, drop_role_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :drop_role_stmt, tag: 182, type: {:message, PgQuery.DropRoleStmt} }, drop_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :drop_stmt, tag: 191, type: {:message, PgQuery.DropStmt} }, drop_subscription_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :drop_subscription_stmt, tag: 259, type: {:message, PgQuery.DropSubscriptionStmt} }, drop_table_space_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :drop_table_space_stmt, tag: 157, type: {:message, PgQuery.DropTableSpaceStmt} }, drop_user_mapping_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :drop_user_mapping_stmt, tag: 170, type: {:message, PgQuery.DropUserMappingStmt} }, dropdb_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :dropdb_stmt, tag: 230, type: {:message, PgQuery.DropdbStmt} }, execute_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :execute_stmt, tag: 247, type: {:message, PgQuery.ExecuteStmt} }, explain_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :explain_stmt, tag: 235, type: {:message, PgQuery.ExplainStmt} }, fetch_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :fetch_stmt, tag: 197, type: {:message, PgQuery.FetchStmt} }, field_select: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :field_select, tag: 23, type: {:message, PgQuery.FieldSelect} }, field_store: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :field_store, tag: 24, type: {:message, PgQuery.FieldStore} }, float: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :float, tag: 261, type: {:message, PgQuery.Float} }, from_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :from_expr, tag: 62, type: {:message, PgQuery.FromExpr} }, func_call: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :func_call, tag: 72, type: {:message, PgQuery.FuncCall} }, func_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :func_expr, tag: 13, type: {:message, PgQuery.FuncExpr} }, function_parameter: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :function_parameter, tag: 203, type: {:message, PgQuery.FunctionParameter} }, grant_role_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :grant_role_stmt, tag: 149, type: {:message, PgQuery.GrantRoleStmt} }, grant_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :grant_stmt, tag: 146, type: {:message, PgQuery.GrantStmt} }, grouping_func: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :grouping_func, tag: 8, type: {:message, PgQuery.GroupingFunc} }, grouping_set: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :grouping_set, tag: 104, type: {:message, PgQuery.GroupingSet} }, import_foreign_schema_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :import_foreign_schema_stmt, tag: 171, type: {:message, PgQuery.ImportForeignSchemaStmt} }, index_elem: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :index_elem, tag: 88, type: {:message, PgQuery.IndexElem} }, index_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :index_stmt, tag: 198, type: {:message, PgQuery.IndexStmt} }, infer_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :infer_clause, tag: 108, type: {:message, PgQuery.InferClause} }, inference_elem: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :inference_elem, tag: 58, type: {:message, PgQuery.InferenceElem} }, inline_code_block: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :inline_code_block, tag: 206, type: {:message, PgQuery.InlineCodeBlock} }, insert_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :insert_stmt, tag: 132, type: {:message, PgQuery.InsertStmt} }, int_list: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :int_list, tag: 266, type: {:message, PgQuery.IntList} }, integer: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :integer, tag: 260, type: {:message, PgQuery.Integer} }, into_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :into_clause, tag: 4, type: {:message, PgQuery.IntoClause} }, join_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :join_expr, tag: 61, type: {:message, PgQuery.JoinExpr} }, json_agg_constructor: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_agg_constructor, tag: 128, type: {:message, PgQuery.JsonAggConstructor} }, json_argument: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_argument, tag: 116, type: {:message, PgQuery.JsonArgument} }, json_array_agg: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_array_agg, tag: 130, type: {:message, PgQuery.JsonArrayAgg} }, json_array_constructor: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_array_constructor, tag: 126, type: {:message, PgQuery.JsonArrayConstructor} }, json_array_query_constructor: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_array_query_constructor, tag: 127, type: {:message, PgQuery.JsonArrayQueryConstructor} }, json_behavior: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_behavior, tag: 45, type: {:message, PgQuery.JsonBehavior} }, json_constructor_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_constructor_expr, tag: 43, type: {:message, PgQuery.JsonConstructorExpr} }, json_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_expr, tag: 46, type: {:message, PgQuery.JsonExpr} }, json_format: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_format, tag: 40, type: {:message, PgQuery.JsonFormat} }, json_func_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_func_expr, tag: 117, type: {:message, PgQuery.JsonFuncExpr} }, json_is_predicate: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_is_predicate, tag: 44, type: {:message, PgQuery.JsonIsPredicate} }, json_key_value: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_key_value, tag: 121, type: {:message, PgQuery.JsonKeyValue} }, json_object_agg: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_object_agg, tag: 129, type: {:message, PgQuery.JsonObjectAgg} }, json_object_constructor: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_object_constructor, tag: 125, type: {:message, PgQuery.JsonObjectConstructor} }, json_output: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_output, tag: 115, type: {:message, PgQuery.JsonOutput} }, json_parse_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_parse_expr, tag: 122, type: {:message, PgQuery.JsonParseExpr} }, json_returning: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_returning, tag: 41, type: {:message, PgQuery.JsonReturning} }, json_scalar_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_scalar_expr, tag: 123, type: {:message, PgQuery.JsonScalarExpr} }, json_serialize_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_serialize_expr, tag: 124, type: {:message, PgQuery.JsonSerializeExpr} }, json_table: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_table, tag: 119, type: {:message, PgQuery.JsonTable} }, json_table_column: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_table_column, tag: 120, type: {:message, PgQuery.JsonTableColumn} }, json_table_path: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_table_path, tag: 47, type: {:message, PgQuery.JsonTablePath} }, json_table_path_scan: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_table_path_scan, tag: 48, type: {:message, PgQuery.JsonTablePathScan} }, json_table_path_spec: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_table_path_spec, tag: 118, type: {:message, PgQuery.JsonTablePathSpec} }, json_table_sibling_join: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_table_sibling_join, tag: 49, type: {:message, PgQuery.JsonTableSiblingJoin} }, json_value_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :json_value_expr, tag: 42, type: {:message, PgQuery.JsonValueExpr} }, list: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :list, tag: 265, type: {:message, PgQuery.List} }, listen_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :listen_stmt, tag: 217, type: {:message, PgQuery.ListenStmt} }, load_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :load_stmt, tag: 225, type: {:message, PgQuery.LoadStmt} }, lock_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :lock_stmt, tag: 240, type: {:message, PgQuery.LockStmt} }, locking_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :locking_clause, tag: 90, type: {:message, PgQuery.LockingClause} }, merge_action: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :merge_action, tag: 52, type: {:message, PgQuery.MergeAction} }, merge_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :merge_stmt, tag: 135, type: {:message, PgQuery.MergeStmt} }, merge_support_func: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :merge_support_func, tag: 11, type: {:message, PgQuery.MergeSupportFunc} }, merge_when_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :merge_when_clause, tag: 113, type: {:message, PgQuery.MergeWhenClause} }, min_max_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :min_max_expr, tag: 37, type: {:message, PgQuery.MinMaxExpr} }, multi_assign_ref: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :multi_assign_ref, tag: 78, type: {:message, PgQuery.MultiAssignRef} }, named_arg_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :named_arg_expr, tag: 14, type: {:message, PgQuery.NamedArgExpr} }, next_value_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :next_value_expr, tag: 57, type: {:message, PgQuery.NextValueExpr} }, notify_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :notify_stmt, tag: 216, type: {:message, PgQuery.NotifyStmt} }, null_if_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :null_if_expr, tag: 17, type: {:message, PgQuery.NullIfExpr} }, null_test: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :null_test, tag: 50, type: {:message, PgQuery.NullTest} }, object_with_args: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :object_with_args, tag: 147, type: {:message, PgQuery.ObjectWithArgs} }, oid_list: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :oid_list, tag: 267, type: {:message, PgQuery.OidList} }, on_conflict_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :on_conflict_clause, tag: 109, type: {:message, PgQuery.OnConflictClause} }, on_conflict_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :on_conflict_expr, tag: 63, type: {:message, PgQuery.OnConflictExpr} }, op_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :op_expr, tag: 15, type: {:message, PgQuery.OpExpr} }, param: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :param, tag: 6, type: {:message, PgQuery.Param} }, param_ref: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :param_ref, tag: 67, type: {:message, PgQuery.ParamRef} }, partition_bound_spec: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :partition_bound_spec, tag: 94, type: {:message, PgQuery.PartitionBoundSpec} }, partition_cmd: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :partition_cmd, tag: 97, type: {:message, PgQuery.PartitionCmd} }, partition_elem: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :partition_elem, tag: 92, type: {:message, PgQuery.PartitionElem} }, partition_range_datum: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :partition_range_datum, tag: 95, type: {:message, PgQuery.PartitionRangeDatum} }, partition_spec: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :partition_spec, tag: 93, type: {:message, PgQuery.PartitionSpec} }, plassign_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :plassign_stmt, tag: 139, type: {:message, PgQuery.PLAssignStmt} }, prepare_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :prepare_stmt, tag: 246, type: {:message, PgQuery.PrepareStmt} }, publication_obj_spec: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :publication_obj_spec, tag: 254, type: {:message, PgQuery.PublicationObjSpec} }, publication_table: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :publication_table, tag: 253, type: {:message, PgQuery.PublicationTable} }, query: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :query, tag: 64, type: {:message, PgQuery.Query} }, range_function: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_function, tag: 82, type: {:message, PgQuery.RangeFunction} }, range_subselect: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_subselect, tag: 81, type: {:message, PgQuery.RangeSubselect} }, range_table_func: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_table_func, tag: 83, type: {:message, PgQuery.RangeTableFunc} }, range_table_func_col: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_table_func_col, tag: 84, type: {:message, PgQuery.RangeTableFuncCol} }, range_table_sample: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_table_sample, tag: 85, type: {:message, PgQuery.RangeTableSample} }, range_tbl_entry: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_tbl_entry, tag: 98, type: {:message, PgQuery.RangeTblEntry} }, range_tbl_function: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_tbl_function, tag: 100, type: {:message, PgQuery.RangeTblFunction} }, range_tbl_ref: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_tbl_ref, tag: 60, type: {:message, PgQuery.RangeTblRef} }, range_var: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :range_var, tag: 2, type: {:message, PgQuery.RangeVar} }, raw_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :raw_stmt, tag: 131, type: {:message, PgQuery.RawStmt} }, reassign_owned_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :reassign_owned_stmt, tag: 250, type: {:message, PgQuery.ReassignOwnedStmt} }, refresh_mat_view_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :refresh_mat_view_stmt, tag: 237, type: {:message, PgQuery.RefreshMatViewStmt} }, reindex_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :reindex_stmt, tag: 242, type: {:message, PgQuery.ReindexStmt} }, relabel_type: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :relabel_type, tag: 25, type: {:message, PgQuery.RelabelType} }, rename_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :rename_stmt, tag: 209, type: {:message, PgQuery.RenameStmt} }, replica_identity_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :replica_identity_stmt, tag: 142, type: {:message, PgQuery.ReplicaIdentityStmt} }, res_target: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :res_target, tag: 77, type: {:message, PgQuery.ResTarget} }, return_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :return_stmt, tag: 138, type: {:message, PgQuery.ReturnStmt} }, role_spec: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :role_spec, tag: 71, type: {:message, PgQuery.RoleSpec} }, row_compare_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :row_compare_expr, tag: 35, type: {:message, PgQuery.RowCompareExpr} }, row_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :row_expr, tag: 34, type: {:message, PgQuery.RowExpr} }, row_mark_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :row_mark_clause, tag: 106, type: {:message, PgQuery.RowMarkClause} }, rtepermission_info: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :rtepermission_info, tag: 99, type: {:message, PgQuery.RTEPermissionInfo} }, rule_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :rule_stmt, tag: 215, type: {:message, PgQuery.RuleStmt} }, scalar_array_op_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :scalar_array_op_expr, tag: 18, type: {:message, PgQuery.ScalarArrayOpExpr} }, sec_label_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :sec_label_stmt, tag: 194, type: {:message, PgQuery.SecLabelStmt} }, select_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :select_stmt, tag: 136, type: {:message, PgQuery.SelectStmt} }, set_operation_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :set_operation_stmt, tag: 137, type: {:message, PgQuery.SetOperationStmt} }, set_to_default: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :set_to_default, tag: 55, type: {:message, PgQuery.SetToDefault} }, single_partition_spec: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :single_partition_spec, tag: 96, type: {:message, PgQuery.SinglePartitionSpec} }, sort_by: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :sort_by, tag: 79, type: {:message, PgQuery.SortBy} }, sort_group_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :sort_group_clause, tag: 103, type: {:message, PgQuery.SortGroupClause} }, sqlvalue_function: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :sqlvalue_function, tag: 38, type: {:message, PgQuery.SQLValueFunction} }, stats_elem: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :stats_elem, tag: 200, type: {:message, PgQuery.StatsElem} }, string: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :string, tag: 263, type: {:message, PgQuery.String} }, sub_link: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :sub_link, tag: 20, type: {:message, PgQuery.SubLink} }, sub_plan: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :sub_plan, tag: 21, type: {:message, PgQuery.SubPlan} }, subscripting_ref: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :subscripting_ref, tag: 12, type: {:message, PgQuery.SubscriptingRef} }, table_func: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :table_func, tag: 3, type: {:message, PgQuery.TableFunc} }, table_like_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :table_like_clause, tag: 87, type: {:message, PgQuery.TableLikeClause} }, table_sample_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :table_sample_clause, tag: 101, type: {:message, PgQuery.TableSampleClause} }, target_entry: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :target_entry, tag: 59, type: {:message, PgQuery.TargetEntry} }, transaction_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :transaction_stmt, tag: 219, type: {:message, PgQuery.TransactionStmt} }, trigger_transition: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :trigger_transition, tag: 114, type: {:message, PgQuery.TriggerTransition} }, truncate_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :truncate_stmt, tag: 192, type: {:message, PgQuery.TruncateStmt} }, type_cast: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :type_cast, tag: 69, type: {:message, PgQuery.TypeCast} }, type_name: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :type_name, tag: 65, type: {:message, PgQuery.TypeName} }, unlisten_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :unlisten_stmt, tag: 218, type: {:message, PgQuery.UnlistenStmt} }, update_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :update_stmt, tag: 134, type: {:message, PgQuery.UpdateStmt} }, vacuum_relation: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :vacuum_relation, tag: 234, type: {:message, PgQuery.VacuumRelation} }, vacuum_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :vacuum_stmt, tag: 233, type: {:message, PgQuery.VacuumStmt} }, var: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :var, tag: 5, type: {:message, PgQuery.Var} }, variable_set_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :variable_set_stmt, tag: 152, type: {:message, PgQuery.VariableSetStmt} }, variable_show_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :variable_show_stmt, tag: 153, type: {:message, PgQuery.VariableShowStmt} }, view_stmt: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :view_stmt, tag: 224, type: {:message, PgQuery.ViewStmt} }, window_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :window_clause, tag: 105, type: {:message, PgQuery.WindowClause} }, window_def: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :window_def, tag: 80, type: {:message, PgQuery.WindowDef} }, window_func: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :window_func, tag: 9, type: {:message, PgQuery.WindowFunc} }, window_func_run_condition: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :window_func_run_condition, tag: 10, type: {:message, PgQuery.WindowFuncRunCondition} }, with_check_option: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :with_check_option, tag: 102, type: {:message, PgQuery.WithCheckOption} }, with_clause: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :with_clause, tag: 107, type: {:message, PgQuery.WithClause} }, xml_expr: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :xml_expr, tag: 39, type: {:message, PgQuery.XmlExpr} }, xml_serialize: %{ __struct__: Protox.Field, extender: nil, kind: %{__struct__: Protox.OneOf, parent: :node}, label: :optional, name: :xml_serialize, tag: 91, type: {:message, PgQuery.XmlSerialize} } }, file_options: nil, name: PgQuery.Node, syntax: :proto3 } end end