Redis vs. SQL Server (MOT)
ืืืจ ืืื ืื ืฉืื ื ืืขืื ืืื ืืืืื ืขื Redis, ืืืืื ืชื ืืืจื ืืืืื ืืืืชืจ ืืืืื ืขื ืื ืืื ืืืฆืื ืงืฉืจ ืืฉืืจ ืืื ืฉืื ื ืขืืฉื ืืืื ืืืื ืืื.
ืชืืืื, ืืื Redis โ
Redis ืืื ื ืืกื ื ืชืื ืื ืฉืขืืื ื In โ Memory ืืชืฆืืจืช Key-Value.
ืืื ืืข ืืื ื Open- Source ืืืื ื ืคืืฅ ืฉืฉืืงื ื700KB ืืืื. ื ืืชื ืืืฉืชืืฉ ืืืกื ื ืชืื ืื ืืื ืืืจ ืื ืืฉืืืช caching โ ืฉืืืืฉ ืขืืงืจื ืืฆื ืืืจืืช ืืืืืช Session-State.
ืืืชืงื ื ืฉื Redis ืคืฉืืื ืืื (ืืืจืกื ืืจืฉืืืช ืืืืกืกืืช ืืขืจืืืช Linux. ืื, ืงืืืืช ืื ืืจืกื ืขื Windows
ืขื Redis ืืืจ ืฉืืขืชื ืืื ืืืื ืืืฉืชืืฉืื ืืื ืื ืืขื ืืืงืืืืชืื ื, ืื ืื ืฉืืืฃ ืืืชื ืืืชืืื ืืืืื ืืช ืื ืืฉื ืืืืชื, ืืจืฆืื ืฉืฉืืขืชื ืAzure Meetup ืฉืืชืงืืืื ืืคืืจืืืจ 2017, ืืฆืขืจื ืขืืืื ืื ืืขืื ืืช ืืืงืืืืช, ืืื ืืืจืฆืื ืืืืชื ืืงืจื ืืงืื ืฉืืกืืืจ ืืืืข ืื ืืชืืืื ืืืฉืชืืฉ ืขื Redis.
ืืื (Hagai Luger), ืกืืคืจ ืฉืืืืจืช ืืื ืง ืฉืขืื, ืขืืื ืืื ืืกื ื ืชืื ืื ืืื ืืื ืืื DBA, ืื ืืืคืฉื ืคืืชืจืื ืฉืืืื ืืืฆืข Cashing, ืืืงืื ืคืชืจืื ืืืขืืืช ืืืฆืืขืื ืืฆืืจื ืงืื ื ืืื ืืคืฉืืื, ืืืืืขื ืืืืชื ืงืื ืืคืฉืืื ืืืืืฆืืขืื ืืื ืืขืืืื.
ืื ื ืจืฆืืชื ืืืฆืข ืืฉืืืืช ืืืฆืืขืื ืืื ืคืืชืจืื ืืืฆืข ื - SQL Server.
ืืื, ืืฉืชืืฉืชื ืขื ืDemo ืฉื Microsoft, ืืืืืืช ืฉืืืืฉ ืืืฉืืืืช ืืืฆืืขืื ืืฉืจืชื SQL Server 2014 ืืืขืื ืขื ืฉืืืืฉ ืIn โ Memory.
ื ืืชื ืืืืื ืืืชืจ ื2 ืืืืืืช ืฉืืืฆืขื ืขื ืDEMO โ
ืืืืืื ืฉื ืDemo, ืืืืืืื ืืื ืืฆื ืืืกืืก-
ืืฆื ืืกืืก โ ืขืืืื ืืื ืืืื ืจืืืื โ aka Base Table.
ืืฆื ืจืืฉืื โ ืืคืืืช ืืืืื ืืืืื ืืืืจืื โ DURABILITY = SCHEMA_AND_DATA
ืืฆื ืฉื ื โ ืฉืื ื ืืฆื ืืืืื ื - DURABILITY = SCHEMA_ONLY
ืืฆื ืฉืืืฉื โ ืฉืื ืื ืืคืจืืฆืืืจื ื NATIVE_COMPILATION โ(DLL)
ืืฆื ืจืืืขื โ ืฉืื ืื DURABILITY(ACID) ืืจืืช ืืกื ืื ืชืื ืื DELAYED_DURABILITY = FORCED
ืืขืช ื ืืกืืฃ ืขืื 2 ืชืืืืืื ืืื ืืืืจ ืืช Redis ืDemo โ
ืชืืืื ืจืืฉืื (ืืฆื ืืืืฉื)-
ืคืจืืืงื ืืงืืจ - RediSQL
ืขืืืื ืขื ืคืจืืืงื ืงืืื - RediSqlโืงืืืื ื ืืขืืืื ืืื Redis ื- SQL Server โ ืืืืจ ืืขืืจืืช
ืื ืฉืืืกืคืชื ืืื ืคืจืืฆืืืจืืช ืฉืขืืคื ืืช ืืืืื ืฉื RediSQL ืืืฆืขื ืืื ืฉืื ืื ืืืคืืืงืฆืื ืืื ืืคืฉืจ ืืืืืง ืืช ืืขืืืื ืขื Redis.
ื ืืชื ืืืืจืื ืืช ืืงืื - ืืื
ืืื ืืขืืืช ืืชืืืื โ
ืืืกืคืชื ืืขืืจ ืSQL ืืื ืืืืืข ืRedis ืืืจืืช ืฉืื ืืื ืฆืืจื ืืื.
ื ืืจืื ืฉSQL ืื ืฆื ืืขื ืง โ ื ืืื ืืช ืื ืฉื ืืกืืชื ืืืืืื.
ืืืคืืืงืฆืื ืฉื ืืืงืจืืกืืคื ืืืืืช DMV ืฉื ื ืืืขื ืืืืืืืช, ืืฉืจ ืขืืจืชื ืืจื Redis ืื ืืืืชื ืฉืื ื ืืืขื ืืืืืืืช SQL Server ืื ืื ืชืื ืื ืื ืืฆืืื ืืช ืืืกืคืจืื ืืจืืืื ืืื.
ืชืืืื ืฉื ื (ืืฆื ืฉืืฉื)-
ืืชืืืชื ืืขืืื ืขื ืืืคืืืงืฆืื ืฉื Microsoft ืืืืืช ืืืืืื,
ืฉืื ืืชื ืืช ืืืคืืืงืฆืื ืฉืชืื ืืขืืื ื2 ืคืืืคืืจืืืช โ Redis + SQL Server. ืืขืฆื, ืคืชืืชื Class ื ืืกืฃ ืฉื TicketReservationDetail ืืฉืจ ืืืื ืคืจืืื ืขื ืืืฉืืช.
ืืืืกืคืชื ืงืืฉืืจ ืืขืืืื ืขื Redis ืืจื StackExchange.Redis
ืฉืื ืืชื ืืช ืืืืืื ืฉื Redis ืืืจืฃ ืืืงืื ืืืจื ืืงืฆืืืช ืืฉื ืื ืืืืืช ืคืขืืืืช ืืฉื ืื ืืื ืื ืฉืื ืคืขืืื ืืชืืกืกืช ืขื ืคืขืืื ืืืืืช ืืืื ื ืชืื, ืืจื ืื ื ืืืืืื ืฉืืคืขืื ืืช ืืฉืจืช.
Single threaded nature of Redis
Redis uses a mostly single threaded design. This means that a single process serves all the client requests, using a technique called multiplexing. This means that Redis can serve a single request in every given moment, so all the requests are served sequentially. This is very similar to how Node.js works as well. However, both products are often not perceived as being slow. This is caused in part by the small amount of time to complete a single request, but primarily because these products are designed to not block on system calls, such as reading data from or writing data to a socket.
I said that Redis is mostly single threaded since actually from Redis 2.4 we use threads in Redis in order to perform some slow I/O operations in the background, mainly related to disk I/O, but this does not change the fact that Redis serves all the requests using a single thread.
ืืงืืจ: https://redis.io/topics/latency
ืืคืขืืืืช ืืชืืกืกื ืขื 2 ืืืื ืืื ืคืฉืืืื INSERT / SELECT โ Set/Get
ื ืืชื ืืืืจืื ืืช ืืืคืืืงืฆืื + ืืฉืื ืืืื ืืื.
ืืขืืจ ืืชืฆืืื ืืืจืฃ ืฉืืจืืชื ืฉืื ืื ืืฉืืขืืชื ืืคืขืืืืช โ
ืืืืืงืช ืืืืช ืื ืชืื ืื ืSQL Server ืืฉืชืืฉื ืSSMS ืืืืืจ. ืืืฉืืื ืืืืื ืืช ืืืืช ืืจืฉืืืืช ืRedis ืืฉืชืืฉืชื ื Redis Desktop Manager
ืืืงืชื ืืช ืืืืช ืืจืฉืืืืช ืฉื ืื ืกื ืืืืื ืืืืจ ืื ืืคืขืื, ืืืืืช SQL Server ืืงืฆืืชื ืืคืื ืืืืื ืฉื ืRedis.
SSMS- SQL Server - 8000 rows
Redis - 32599 keys = rows.
32 ืืืฃ ืRedis ืื ืืื 8 ืืืฃ ืืฉืจืช SQL Server.