ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dma...@apache.org
Subject ignite git commit: Updated Ignite description
Date Fri, 15 Sep 2017 20:31:22 GMT
Repository: ignite
Updated Branches:
  refs/heads/master 2da8861a2 -> b86153208


Updated Ignite description


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/b8615320
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/b8615320
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/b8615320

Branch: refs/heads/master
Commit: b86153208f28cfd76c9d21b6170d228e23deaead
Parents: 2da8861
Author: Denis Magda <dmagda@gridgain.com>
Authored: Fri Sep 15 13:31:19 2017 -0700
Committer: Denis Magda <dmagda@gridgain.com>
Committed: Fri Sep 15 13:31:19 2017 -0700

----------------------------------------------------------------------
 README.md | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/b8615320/README.md
----------------------------------------------------------------------
diff --git a/README.md b/README.md
index b6b5987..59baf90 100644
--- a/README.md
+++ b/README.md
@@ -19,33 +19,47 @@ with powerful <b>SQL</b>, <b>key-value</b> and
<b>processing</b> APIs.
 ## Durable Memory
 Ignite's durable memory component treats RAM not just as a caching layer but as a complete
fully functional storage layer. This means that users can turn the persistence on and off
as needed. If the persistence is off, then Ignite can act as a distributed **in-memory database**
or **in-memory data grid**, depending on whether you prefer to use SQL or key-value APIs.
If the persistence is turned on, then Ignite becomes a distributed, **horizontally scalable
database** that guarantees full data consistency and is resilient to full cluster failures.
 
+[Read More](https://apacheignite.readme.io/docs/durable-memory)
+
 ## Ignite Persistence
 
-Ignite Native Persistence is a distributed ACID and SQL-compliant disk store that transparently
integrates with Ignite's Durable Memory as an optional disk layer storing data and indexes
on SSD, Flash, 3D XPoint, and other types of non-volatile storages.
+Ignite Native Persistence is a distributed, ACID, and SQL-compliant **disk store** that transparently
integrates with Ignite's Durable Memory as an optional disk layer storing data and indexes
on SSD, Flash, 3D XPoint, and other types of non-volatile storages.
 
 With the Ignite Persistence enabled, you no longer need to keep all the data and indexes
in memory or warm it up after a node or cluster restart because the Durable Memory is tightly
coupled with persistence and treats it as a secondary memory tier. This implies that if a
subset of data or an index is missing in RAM, the Durable Memory will take it from the disk.
 
 <p align="center">
     <a href="https://apacheignite.readme.io/docs/distributed-persistent-store">
-        <img src="https://ignite.apache.org/images/check_pointing-2.png" width="400px"/>
+        <img src="https://ignite.apache.org/images/native_persistence.png" width="400px"/>
     </a>
 </p>
 
+[Read More](https://apacheignite.readme.io/docs/distributed-persistent-store)
+
 ## ACID Compliance
 Data stored in Ignite is ACID-compliant both in memory and on disk, making Ignite a **strongly
consistent** system. Ignite transactions work across the network and can span multiple servers.
 
+[Read More](https://apacheignite.readme.io/docs/transactions)
+
 ## Complete SQL Support
 Ignite provides full support for SQL, DDL and DML, allowing users to interact with Ignite
using pure SQL without writing any code. This means that users can create tables and indexes
as well as insert, update, and query data using only SQL. Having such complete SQL support
makes Ignite a one-of-a-kind **distributed SQL database**.
 
+[Read More](https://apacheignite.readme.io/docs/distributed-sql)
+
 ## Key-Value
 The in-memory data grid component in Ignite is a fully transactional **distributed key-value
store** that can scale horizontally across 100s of servers in the cluster. When persistence
is enabled, Ignite can also store more data than fits in memory and survive full cluster restarts.
 
+[Read More](https://apacheignite.readme.io/docs/data-grid)
+
 ## Collocated Processing
 Most traditional databases work in a client-server fashion, meaning that data must be brought
to the client side for processing. This approach requires lots of data movement from servers
to clients and generally does not scale. Ignite, on the other hand, allows for sending light-weight
computations to the data, i.e. **collocating** computations with data. As a result, Ignite
scales better and minimizes data movement.
 
+[Read More](https://apacheignite.readme.io/docs/collocate-compute-and-data)
+
 ## Scalability and Durability
 Ignite is an elastic, horizontally scalable distributed system that supports adding and removing
cluster nodes on demand. Ignite also allows for storing multiple copies of the data, making
it resilient to partial cluster failures. If the persistence is enabled, then data stored
in Ignite will also survive full cluster failures. Cluster restarts in Ignite can be very
fast, as the data becomes operational instantaneously directly from disk. As a result, the
data does not need to be preloaded in-memory to begin processing, and Ignite caches will lazily
warm up resuming the in memory performance.
 
+[Read More](https://apacheignite.readme.io/docs/clustering)
+
 ## Ignite Facts
 
 <b>Is Ignite a persistent or pure in-memory storage?</b><br/>


Mime
View raw message