type
Mongo.auth
=
{ 
string
 
user
, 
string
 
password
 }
type
type
Mongo.collStatsType
=
{ 
string
 
ns
, 
Bson.int32
 
count
, 
Bson.int32
 
size
, 
float
 
avgObjSize
, 
Bson.int32
 
storageSize
, 
Bson.int32
 
numExtents
, 
Bson.int32
 
nindexes
, 
Bson.int32
 
lastExtentSize
, 
float
 
paddingFactor
, 
Bson.int32
 
flags
, 
Bson.int32
 
totalIndexSize
, 
{ 
 }
 
indexSizes
, 
int
 
ok
 }
type =
type =
{ 
 
collection
, 
Mongo.cursor
 
cursor
, 
 
query
, 
bool
 
ignore_incomplete
 }
type
Mongo.concurrency
=
Variant
  •    
    { 
    void
     
    pool
     }
  • or 
    { 
    void
     
    cell
     }
  • or 
    { 
    void
     
    singlethreaded
     }
type
Mongo.conf
=
{ 
int
 
bufsize
, 
int
 
poolmax
, 
bool
 
slaveok
, 
int
 
attempt
, 
bool
 
verbose
, 
Mongo.auths
 
auths
, 
int
 
timeout
, 
int
 
waiting
, 
option
(
string
)
 
replica
 }
type
Mongo.db
type
Mongo.delete_tag
=
{ 
void
 
SingleRemove
 }
type
Mongo.dropDatabaseType
=
{ 
string
 
dropped
, 
int
 
ok
 }
type
Mongo.explainType
=
{ 
string
 
cursor
, 
int
 
nscanned
, 
int
 
nscannedObjects
, 
int
 
n
, 
bool
 
scanAndOrder
, 
int
 
millis
, 
int
 
nYields
, 
int
 
nChunkSkips
, 
bool
 
isMultiKey
, 
bool
 
indexOnly
, 
Bson.document
 
indexBounds
, 
list
(
{ 
string
 
cursor
, 
Bson.document
 
indexBounds
 }
)
 
allPlans
, 
 }
type
Mongo.failure
=
Variant
  •    
    { 
    void
     
    OK
     }
  • or 
    { 
    string
     
    Error
     }
  • or 
    { 
    Bson.document
     
    DocError
     }
  • or 
    { 
    void
     
    Incomplete
     }
  • or 
    { 
    void
     
    NotFound
     }
  • or 
    { 
    void
     
    SlaveOK
     }
type
Mongo.foreign
(
α
, 
β
, 
γ
, 
δ
, 
ε
)
type =
{ 
list
(
α
)
 
retval
, 
int
 
count
, 
int
 
keys
, 
int
 
ok
 }
type
Mongo.index_tag
=
Variant
  •    
    { 
    void
     
    Unique
     }
  • or 
    { 
    void
     
    DropDups
     }
  • or 
    { 
    void
     
    Background
     }
  • or 
    { 
    void
     
    Sparse
     }
type
Mongo.insert_tag
=
{ 
void
 
ContinueOnError
 }
type
Mongo.isMaster
=
{ 
bool
 
ismaster
, 
 
msg
, 
 
me
, 
 
setName
, 
 
primary
, 
 
secondary
, 
 
hosts
, 
 
passives
, 
 
arbiters
, 
int
 
maxBsonObjectSize
, 
int
 
ok
 }
type
Mongo.lastError
=
{ 
int
 
ok
, 
 
err
, 
 
code
, 
 
connectionId
, 
 }
type
Mongo.listDatabasesType
=
{ 
list
(
{ 
string
 
name
, 
float
 
sizeOnDisk
, 
bool
 
empty
 }
)
 
databases
, 
float
 
totalSize
, 
int
 
ok
 }
type
Mongo.logtype
=
Variant
  •    
    { 
    void
     
    stdout
     }
  • or 
    { 
    void
     
    stderr
     }
  • or 
    { 
    void
     
    logger
     }
  • or 
    { 
    void
     
    nomongolog
     }
type
Mongo.mapReduceOptions
=
{ 
option
(
int
)
 
limit
, 
 
keeptemp
, 
option
(
string
)
 
finalize
, 
 
jsMode
, 
 
verbose
 }
type
Mongo.mapReduceType
=
{ 
Bson.meta
 
result
, 
int
 
timeMillis
, 
{ 
int
 
input
, 
int
 
emit
, 
int
 
output
, 
 
reduce
 }
 
counts
, 
int
 
ok
 }
type
Mongo.member
=
{ 
string
 
host
, 
 
arbiterOnly
, 
 
buildIndexes
, 
 
priority
, 
 }
type
Mongo.mongo_host
=
(
string
, 
int
)
type
Mongo.mongo_tag
=
Variant
type
Mongo.ok
=
{ 
int
 
ok
 }
type
Mongo.pkg
(
'value
)
=
(
, 
{ 
 
select
, 
 
update
, 
Mongo.select
(
'value
)
 
sempty
, 
Mongo.update
(
'value
)
 
uempty
 }
)
type
Mongo.query_tag
=
Variant
  •    
    { 
    void
     
    TailableCursor
     }
  • or 
    { 
    void
     
    SlaveOk
     }
  • or 
    { 
    void
     
    OplogReplay
     }
  • or 
    { 
    void
     
    NoCursorTimeout
     }
  • or 
    { 
    void
     
    AwaitData
     }
  • or 
    { 
    void
     
    Exhaust
     }
  • or 
    { 
    void
     
    Partial
     }
type
Mongo.replSetGetStatus
=
{ 
string
 
set
, 
Date.date
 
date
, 
Bson.int32
 
myState
, 
 
syncingTo
, 
list
(
{ 
 
_id
, 
string
 
name
, 
 
errmsg
, 
 
stateStr
, 
 
optimeDate
, 
 
lastHeartbeat
, 
 }
)
 
members
, 
bool
 
ok
, 
 
errmsg
 }
type
Mongo.replSetInitiate
=
{ 
string
 
_id
, 
 
members
, 
 
settings
 }
type
Mongo.reply_tag
=
Variant
  •    
    { 
    void
     
    CursorNotFound
     }
  • or 
    { 
    void
     
    QueryFailure
     }
  • or 
    { 
    void
     
    ShardConfigStale
     }
  • or 
    { 
    void
     
    AwaitCapable
     }
type
type
Mongo.serverStatusType
=
{ 
string
 
host
, 
string
 
version
, 
string
 
process
, 
float
 
uptime
, 
float
 
uptimeEstimate
, 
Date.date
 
localTime
, 
{ 
float
 
totalTime
, 
float
 
lockTime
, 
float
 
ratio
, 
{ 
int
 
total
, 
int
 
readers
, 
int
 
writers
 }
 
currentQueue
, 
{ 
int
 
total
, 
int
 
readers
, 
int
 
writers
 }
 
activeClients
 }
 
globalLock
, 
{ 
int
 
bits
, 
int
 
resident
, 
int
 
virtual
, 
bool
 
supported
, 
int
 
mapped
 }
 
mem
, 
{ 
int
 
current
, 
int
 
available
 }
 
connections
, 
{ 
string
 
note
, 
int
 
heap_usage_bytes
, 
int
 
page_faults
 }
 
extra_info
, 
{ 
{ 
int
 
accesses
, 
int
 
hits
, 
int
 
misses
, 
int
 
resets
, 
float
 
missRatio
 }
 
btree
 }
 
indexCounters
, 
{ 
int
 
flushes
, 
int
 
total_ms
, 
float
 
average_ms
, 
int
 
last_ms
, 
Date.date
 
last_finished
 }
 
backgroundFlushing
, 
{ 
int
 
totalOpen
, 
int
 
clientCursors_size
, 
int
 
timedOut
 }
 
cursors
, 
{ 
int
 
bytesIn
, 
int
 
bytesOut
, 
int
 
numRequests
 }
 
network
, 
{ 
int
 
insert
, 
int
 
query
, 
int
 
update
, 
int
 
delete
, 
int
 
getmore
, 
int
 
command
 }
 
opcounters
, 
{ 
int
 
regular
, 
int
 
warning
, 
int
 
msg
, 
int
 
user
, 
int
 
rollovers
 }
 
asserts
, 
bool
 
writeBacksQueued
, 
Bson.register
(
{ 
 
setName
, 
bool
 
ismaster
, 
 
secondary
, 
 
hosts
, 
 
primary
 }
)
 
repl
, 
int
 
ok
 }
type
Mongo.su_status
=
Variant
  •    
    { 
    void
     
    su_select
     }
  • or 
    { 
    void
     
    su_update
     }
  • or 
    { 
    void
     
    su_either
     }
  • or 
    { 
    void
     
    su_key
     }
type
type
Mongo.update_tag
=
Variant
  •    
    { 
    void
     
    Upsert
     }
  • or 
    { 
    void
     
    MultiUpdate
     }
type
Mongo.view
(
α
, 
β
)

Comments

The browser you use is not supported by this application, probably because it lacks some critical features.
For a better experience, please consider using this application with a supported browser.