void TopologicalOrderSchemaNodes()

in backend/schema/printer/print_ddl.cc [547:629]
71 lines of code
21 McCabe index (conditional complexity)

void TopologicalOrderSchemaNodes(
    const SchemaNode* node, absl::flat_hash_set<const SchemaNode*>* visited,
    std::vector<std::string>* statements) {
  if (visited->find(node) != visited->end()) {
    return;
  }
  visited->insert(node);

  if (const View* view = node->As<const View>(); view != nullptr) {
    for (auto dependency : view->dependencies()) {
      TopologicalOrderSchemaNodes(dependency, visited, statements);
    }
    statements->push_back(PrintView(view));
  }

  if (const Table* table = node->As<const Table>(); table != nullptr) {
    for (const Column* column : table->columns()) {
      for (const Column* column_dep : column->dependent_columns()) {
        TopologicalOrderSchemaNodes(column_dep->table(), visited, statements);
      }
      for (const SchemaNode* sequence_dep : column->sequences_used()) {
        TopologicalOrderSchemaNodes(sequence_dep, visited, statements);
      }
      for (const SchemaNode* udf_dep : column->udf_dependencies()) {
        TopologicalOrderSchemaNodes(udf_dep, visited, statements);
      }
      // Omitting indexes since their dependencies to UDFs are through columns.
    }
    for (const CheckConstraint* check_constraint : table->check_constraints()) {
      for (const SchemaNode* udf_dep : check_constraint->udf_dependencies()) {
        TopologicalOrderSchemaNodes(udf_dep, visited, statements);
      }
    }

    statements->push_back(PrintTable(table));
    std::vector<const Index*> indexes{table->indexes().begin(),
                                      table->indexes().end()};
    std::sort(indexes.begin(), indexes.end(),
              [](const Index* i1, const Index* i2) {
                return i1->Name() < i2->Name();
              });
    for (const Index* index : indexes) {
      if (!index->is_managed()) {
        statements->push_back(PrintIndex(index));
      }
    }
  }

  if (const Udf* udf = node->As<const Udf>(); udf != nullptr) {
    for (const SchemaNode* udf_dep : udf->dependencies()) {
      TopologicalOrderSchemaNodes(udf_dep, visited, statements);
    }

    statements->push_back(PrintUdf(udf));
  }

  if (const Sequence* sequence = node->As<const Sequence>();
      sequence != nullptr) {
    // Not an internal sequence, e.g., used by an identity column.
    if (!absl::StartsWith(sequence->Name(), "_")) {
      statements->push_back(PrintSequence(sequence));
    }
  }

  if (const ChangeStream* change_stream = node->As<ChangeStream>();
      change_stream != nullptr) {
    statements->push_back(PrintChangeStream(change_stream));
  }

  if (const Placement* placement = node->As<Placement>();
      placement != nullptr) {
    statements->push_back(PrintPlacement(placement));
  }

  if (const Model* model = node->As<const Model>(); model != nullptr) {
    statements->push_back(PrintModel(model));
  }

  if (const PropertyGraph* property_graph = node->As<const PropertyGraph>();
      property_graph != nullptr) {
    statements->push_back(PrintPropertyGraph(property_graph));
  }
}