<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<link rel="canonical" href="https://ignite.apache.org/releases/2.10.0/javadoc/org/apache/ignite/spi/systemview/view/package-frame.html" />
<META NAME="ROBOTS" CONTENT="NOINDEX">
<!-- Yandex.Metrika counter -->
    <script type="text/javascript" >
      (function(m,e,t,r,i,k,a){m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)};
      m[i].l=1*new Date();k=e.createElement(t),a=e.getElementsByTagName(t)[0],k.async=1,k.src=r,a.parentNode.insertBefore(k,a)})
      (window, document, "script", "https://mc.yandex.ru/metrika/tag.js", "ym");
    
      ym(72949126, "init", {
           clickmap:true,
           trackLinks:true,
           accurateTrackBounce:true,
           webvisor:true
      });
    </script>
    <noscript><div><img src="https://mc.yandex.ru/watch/72949126" style="position:absolute; left:-9999px;" alt="" /></div></noscript>
    <!-- /Yandex.Metrika counter -->
<script type='text/javascript'>
    window.__lo_site_id = 284467;
    
      (function() {
        var wa = document.createElement('script'); wa.type = 'text/javascript'; wa.async = true;
        wa.src = 'https://d10lpsik1i8c69.cloudfront.net/w.js';
        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(wa, s);
        })();
      </script>

<!-- Generated by javadoc (1.8.0_261) on Thu Mar 11 02:15:48 MSK 2021 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>org.apache.ignite.spi.systemview.view (Ignite 2.10.0)</title>
<meta name="date" content="2021-03-11">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
<link rel='shortcut icon' href='https://ignite.apache.org/favicon.ico'/>

<script async src="https://www.googletagmanager.com/gtag/js?id=UA-61232409-1"></script>
    <script>
      window.dataLayer = window.dataLayer || [];
      function gtag(){dataLayer.push(arguments);}
      gtag('js', new Date());
    
      gtag('config', 'UA-61232409-1');
    </script></head>

<body>
<h1 class="bar"><a href="../../../../../../org/apache/ignite/spi/systemview/view/package-summary.html" target="classFrame">org.apache.ignite.spi.systemview.view</a></h1>
<div class="indexContainer">
<h2 title="Interfaces">Interfaces</h2>
<ul title="Interfaces">
<li><a href="FiltrableSystemView.html" title="interface in org.apache.ignite.spi.systemview.view" target="classFrame"><span class="interfaceName">FiltrableSystemView</span></a></li>
<li><a href="SystemView.html" title="interface in org.apache.ignite.spi.systemview.view" target="classFrame"><span class="interfaceName">SystemView</span></a></li>
<li><a href="SystemViewRowAttributeWalker.html" title="interface in org.apache.ignite.spi.systemview.view" target="classFrame"><span class="interfaceName">SystemViewRowAttributeWalker</span></a></li>
<li><a href="SystemViewRowAttributeWalker.AttributeVisitor.html" title="interface in org.apache.ignite.spi.systemview.view" target="classFrame"><span class="interfaceName">SystemViewRowAttributeWalker.AttributeVisitor</span></a></li>
<li><a href="SystemViewRowAttributeWalker.AttributeWithValueVisitor.html" title="interface in org.apache.ignite.spi.systemview.view" target="classFrame"><span class="interfaceName">SystemViewRowAttributeWalker.AttributeWithValueVisitor</span></a></li>
</ul>
<h2 title="Classes">Classes</h2>
<ul title="Classes">
<li><a href="BinaryMetadataView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">BinaryMetadataView</a></li>
<li><a href="CacheGroupView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">CacheGroupView</a></li>
<li><a href="CachePagesListView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">CachePagesListView</a></li>
<li><a href="CacheView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">CacheView</a></li>
<li><a href="ClientConnectionView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">ClientConnectionView</a></li>
<li><a href="ClusterNodeView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">ClusterNodeView</a></li>
<li><a href="ComputeJobView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">ComputeJobView</a></li>
<li><a href="ComputeTaskView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">ComputeTaskView</a></li>
<li><a href="ContinuousQueryView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">ContinuousQueryView</a></li>
<li><a href="MetastorageView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">MetastorageView</a></li>
<li><a href="PagesListView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">PagesListView</a></li>
<li><a href="PartitionStateView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">PartitionStateView</a></li>
<li><a href="ScanQueryView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">ScanQueryView</a></li>
<li><a href="ServiceView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">ServiceView</a></li>
<li><a href="SqlIndexView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlIndexView</a></li>
<li><a href="SqlQueryHistoryView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlQueryHistoryView</a></li>
<li><a href="SqlQueryView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlQueryView</a></li>
<li><a href="SqlSchemaView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlSchemaView</a></li>
<li><a href="SqlTableColumnView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlTableColumnView</a></li>
<li><a href="SqlTableView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlTableView</a></li>
<li><a href="SqlViewColumnView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlViewColumnView</a></li>
<li><a href="SqlViewView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">SqlViewView</a></li>
<li><a href="StripedExecutorTaskView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">StripedExecutorTaskView</a></li>
<li><a href="TransactionView.html" title="class in org.apache.ignite.spi.systemview.view" target="classFrame">TransactionView</a></li>
</ul>
<h2 title="Enums">Enums</h2>
<ul title="Enums">
<li><a href="ComputeJobView.ComputeJobState.html" title="enum in org.apache.ignite.spi.systemview.view" target="classFrame">ComputeJobView.ComputeJobState</a></li>
</ul>
</div>
</body>
</html>
