Index
A
ACID transactions
Advanced patterns
attribute pattern
subsetting
hybrid bucket data model
orders
read performance/updates
risks
two-collection design
vertical partitioning
aggregate()command
Aggregation pipelines
Aggregation pipeline vs. multiple updates
All or nothing approach
Application workload
Atlas Data Lake
Atlas Full-Text Search
B
Balanced tree (B-tree) indexes
add entry
advantages
BAKER
case-insensitive searches
index scans
index splits
leaf blocks
NIVEN
selectivity
structure
unique index
Balancer window
Binary JSON (BSON)
C
Caching
film title
implement
performance improvements
Cautionary tale
Collection scan
Compound indexes
advantage
covering index
creation
definition
find()/$match clauses
guidelines
initial/leading attributes
key order
performance
uses
Consistency mechanisms
limitations
non-relational databases
read preference
relational databases
settings
transactions
write concern
createCollection method
Current operations
db.currentOp() command
db.killOp
db.serverStatus()
filter
inprog
tuning situation
$all
$ownOps
Custer tuning
D
Database
application layer
layers
MongoDB database server
steps
storage engine
storage subsystem
Database-as-a-service (DBaaS)
Data manipulation statements
db.getProfilingStatus() command
dbPath directory
db.serverStatus() command
Delete optimizations
Disk IO
detecting/solving problems
disk hardware
HDD
latency
queuing
sequencial/random
subsystem bandwidth
cloud storage
disks
MAngoDB Atlas
storage arrays
throughput
Disk sort vs. indexed sort
Disk sort vs. memory sort
E
explain() method
alternate plans
choices
command
cursor
execution plan
execution statistics
executionStages section
executionSteps subdocument
mongoTuning.executionStats()
types
fundamental procedures
inputStage
MongoDB documentation
optimizer’s decisions
query
tune query
visual explain utilities
dbKoda product
MongoDB Compass
winningPlan
winningPlan
F
Filter optimizations
Filter strategies
array queries
not equals conditions
range queries
regular expressions
$exists operation
$or/$in
find() command
Flexible document schema model
G
Geospatial data
Geospatial indexes
creation
error
execution plan
GeoJSON format
geospatial data
limitations
performance
query
types
$near operator
getShardDistribution() method
Google Cloud Platform (GCP)
H
Hashed shard keys
Host-level monitoring
CPU
Disk IO
memory
network
operating system
I
Indexed vs. non-indexed
Indexes
definition
joins
maintenance
partial
query performance
sorting
sparse
wildcard index
creation
data
definition
vs. find operations
naming
performance
uses
vs. traditional indexes
Index merges
Index vs. scan
optimizer
pick/create
sort operations
statements
Inserting data
batch processing
cloning
load from files
iostat command
J, K
JavaScript Object Notation (JSON)
L
Latency
Linking vs. embedding
advantages
customer data
aggregation
performance
query
definitions
deleting customers
indexes
information
logical entities
new orders
non-performance-related reasons
open orders
Orders schema
performance
top products
updating products
M
Magnetic disk or hard disk drive (HDD)
Materialized views
Materialized view vs. direct view
maxStalenessSeconds
mdadm command
Memory tuning
MongoDB memory architecture
application memory, reducing
host memory
measuring memory
WiredTiger storage engine
Memory utilization
MongoDB
architecture
cluster balancing
mongod
replica sets
sharding
storage engine
commands
aggregate() command
categories
data manipulation commands
find() command
document model
BSON
collections
JSON
schemas
drivers
logs
command-specific information
critical metrics
db.setLogLevel
elements
executed query
file location
grep
grep
logLevel
logpath parameter
mtools
slow operations
view
protocol
communication mechanism
wire
MongoDB Atlas
analyzers
data lake
query duration
search
MongoDB Compass
MongoDB IO
architecture
datafile
journal
temporary file
types
WiredTiger cache
MongoDB optimizer
MongoDB server monitoring
Atlas
compass
free monitoring
Ops manager
third-party monitoring tools
MongoDB transactions
definition
drivers
limits
performance implications, TransientTransactionErrors
TransientTransactionErrors
mongoTuning.quickExplain function
Multi-level cell (MLC)
Multiple collections
graph lookups
join order
Multi-Version Concurrency Control (MVCC)
N
Network transmission
application architecture
batch processing
bulk inserts
projections
O
Operating system monitoring
Optimizing views
P
Partial index
Physical IO
Q
Query optimization
Query profiler
levels
profiling data
accurate picture
aggregating statistics
execution plans
explain()
general approach
getMore operation
mongoTuning.profileQuery()
queries
queryHash
query shape
system.profile
profiling level
setProfilingLevel
arguments
syntax
system.profile collection
R
Read preference
maxStalenessSeconds
read performance
secondaries
settings
tag sets
Regular expressions
Replica sets
S
Schema modelling
guiding principles
key objectives
third normal form
Server monitoring
host-level
MAngoDB
phases
Server statistics
db.serverStatus() command
categories
counts
outputs
problems
WiredTiger cache
db.serverStatus() command
outputs
helper function
MongoDB Atlas/Ops Manager
mongoTuning package
mongoTuning.keyServerStats
operations
Shard balance
changing/recreating keys
chunk size
disable
window
Sharded queries
accidental merge
aggregations/sorts
explain() method
key lookups
key range
non-shared key loops
sorting
$lookup
Sharding
concepts
hash-based
key selection
performance
range-based
scaling
zone
Single-level cell (SLC)
Solid State Drives (SSDs)
definition
garbage collection/wear levelling
magnetic disk
SATA vs. PCI
storage hierarchy
write endurance
write performance
Sort aggregation pipelines
disk sorts
indexed
Sparse index
Storage arrays
cloud storage
hardware storage
non-volatile caches, RAID 5 devices
RAID
RAID 5 write penalty
Suffix stemming
Symptomatic performance tuning
Systematic performance tuning
T
Tag sets
Text indexes
compound indexes
create index
exact matching
exclusions
limitations
multiple attributes
performance
collection scan
considerations
index scans
vs. number of search terms
query
sort
suffix stemming
$text operator
textScore field
tuning/creating
weight
$text operator
_tmp directory
transactionLifetimeLimitSeconds parameter
Transactions
definition
MongoDB
MVCC
optimization
avoiding transaction
ordering operations
partition hot documents
theory
throughput
Tune aggregation pipelines
optimizations
ordering
U
Unused indexes
Updating data
bulk
multi:false
multi:true
upserts
$merge
Upserts
V
vmstat command
W
Wear levelling
WiredTiger memory
cache size
checkpoints
concurrency
database cache hit ratio
database cache hit ratio
evictions
optimum cache size
WiredTiger memory-based cache
WiredTiger storage engine
Wire protocol
Write concern
effect
journal
secondary reads
w option
X, Y
$exists operation
$lookup pipeline
$merge aggregation
Z
Zone sharding
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.