MongoDB-Nutzung in PHP

1. Grundkonzepte von Mongodb
1. Benennungsregeln der Mongodb-Datenbank:
darf keine leere Zeichenfolge ("") sein.
darf kein '' (Leerzeichen), ., $, /, und enthalten

D:mongodbbin>mongo
Alternativ navigieren Sie im Windows Explorer zu C:mongobin und doppelklicken Sie auf mongo.exe.
Unabhängig davon, welche Methode Sie zum Starten wählen, wird die Shell angezeigt
MongoDB-Shell-Version: 1.6.5
Verbindung zu: Test wird hergestellt
>
Jetzt mit dem Testserver verbunden.
2.MongoDB-Installation und -Konfiguration unter Linux
1. Für 32-Bit-Linux
$ curl http://downloads.mongodb.org/linux/mongodb-linux-i686-1.4.4.tgz > mongo.tgz
$ tar xzf mongo.tgz
Für 64-Bit-Linux
$ curl http://downloads.mongodb.org/linux/mongodb-linux-x86_64-1.4.4.tgz > mongo .tgz
$ tar xzf mongo.tgz Wenn Curl nicht installiert ist, installieren Sie apt-get install curl
2. Standardmäßig speichert MongoDB Daten im Ordner /data/db/ Der Ordner muss manuell erstellt werden. Erstellen Sie es wie folgt: $ adduser mongodb $ passwd mongodb $ sudo mkdir -p /data/db/ $ sudo chown `id -u` /data/db $ chown -R mongodb:mongodb /data Natürlich können Sie es über angeben Der Befehl --dbpath MongoDB speichert Daten in einem anderen Verzeichnis.
3. Lassen Sie die Datenbank in der Konsole laufen: $ nohup ./mongodb-xxxxxxx/bin/mongod & $ ./mongodb-xxxxxxx/bin/mongo > db.foo.save( { a : 1 } ) > db .foo .find() Das Ergebnis ist: { "_id" : ObjectId("4cd181a31415ffb41a094f43"), "a" : 1 } OK! !
2. Mongodb-Anweisungen und zugehörige Vorgänge
a) Befehl „show“
ii Geben Sie show db in dos ein, um alle aktuellen Datenbanken anzuzeigen
>show dbs
admin
alphabet
color
colors
lokal
mymongo
test
>
iii Alle Tabellen in der aktuellen Datenbank anzeigen
>mymongo verwenden
auf db mymongo umgestellt
>Sammlungen anzeigen
colors
shell.colors
system.indexes
>
b) Befehl verwenden
i Geben Sie die Datenbank an, die Sie aktuell verwenden müssen. Wenn nicht, erstellen Sie eine neue Bibliothek. Wenn in dieser Bibliothek keine Daten vorhanden sind, wird das System nach einiger Zeit zerstört
ii. Verwenden Sie [Datenbankname]
c) Befehl einfügen
i Daten im JSON-Format hinzufügen
ii. Wenn in den hinzugefügten Daten keine Tabelle vorhanden ist, wird eine neue Tabelle erstellt und die Daten werden der Tabelle
iii db.[table name].insert()
> db.dingdan hinzugefügt. insert(
. .. {
... order_id: 109384,
... order_date: neues Datum("12/04/2010"),
... Kunde: {
... Name: „Joe Bloggs“,
... Firma: „XYZ Inc.“,
... Telefon: „(555) 123-4567“
... },
... Zahlung: {
... Typ: "Bargeld",
... Betrag: 4075,99,
... bezahlt_in_vollständig: wahr
... },
... Artikel: [
... {
... SKU: "ABC1200",
... Beschreibung: "Ein Beispielprodukt",
... Menge: 1,
... Preis_pro_Einheit: 75,99,
... }, {
... Artikelnummer: "XYZ3400",
... Beschreibung: "Ein teures Produkt",
... Menge: 2,
...            Preis pro Einheit: 2000
...                                                                                                                                     🎜>d) Speicherbefehl
i. Speichern Sie die Daten
ii Daten in die Tabelle
iii. Wenn die Daten in der Tabelle vorhanden sind, ändern Sie die neuen Daten
iv x ist das zu aktualisierende Objekt, bei dem es sich nur um einen einzelnen Datensatz handeln kann.
Wenn in der Sammlung bereits ein Datensatz mit derselben „_id“ wie das x-Objekt vorhanden ist. Mongodb ersetzt den vorhandenen Datensatz in der Sammlung durch das x-Objekt. Andernfalls wird das x-Objekt eingefügt. Wenn in x keine _id vorhanden ist, generiert das System automatisch eines und fügt es ein. Dies entspricht der Situation von upsert=true und multi=false in der obigen Update-Anweisung.

db.test0.save({count:40,test1:"OK"}); _id Das System generiert
db.test0.save({_id:40,count:40,test1:"OK" } ); Wenn in test0 eine _id gleich 40 vorhanden ist, wird diese ersetzt, andernfalls wird sie eingefügt.
e) Befehl zum Entfernen
i. Löschen Sie ein in der Tabelle angegebenes Datenelement
ii db .colors.save({"color":"112233"})
> db.colors.find()
{ "_id" : ObjectId("4e9bc2024fadb58af17b2f01"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc2374fadb58af17b2f02"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc2384fadb58af17b2f03"), "color" : "ff0000" }
{ " _id" : ObjectId("4e9bc2394fadb58af17b2f04"), "color" : "ff0000" ObjectID ("4E9BC23A4FADB58AF17B2F06"), "Farbe": "ff0000"}
{"_id": ObjectID ("4E9BC23A4FADB58AF17B2F07"), "Color": "4. fadb58af17b2f08" ), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc23b4fadb58af17b2f09"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc23c4fadb58af17b2f0 a"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc23c4fadb58af17b2f0b"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc23d4fadb58af17b2f0c"), "color" : ff0000 112233"})
> db.colors.find()
{ "_id" : ObjectId("4e9bc2024fadb58af17b2f01"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc2374fadb58af17b2f02 "), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc2384fadb58af17b2f03"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc2394fadb58af17b2f04"), " color" : "ff0000" }
{ "_id" : ObjectId("4e9bc2394fadb58af17b2f05"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc23a4fadb58af17b2f06"), "color" : " ff0000" }
{ "_id" : ObjectId("4e9bc23a4fadb58af17b2f07"), "color" : "ff0000" ?? _id" : ObjectId("4e9bc23c4fadb58af17b2f0b"), "color" : "ff0000" }
{ "_id" : ObjectId("4e9bc23d4fadb58af17b2f0c"), "color" : "ff0000" }
f) Aktualisierungsbefehl
i. Daten ändern
ii. db.[Tabellenname].update()
db.collection.update( Kriterien, objNew, upsert, multi )

Kriterien: Abfragebedingungen aktualisieren, ähnlich nach
objNew in der SQL-Aktualisierungsabfrage: Objekt aktualisieren und einige Aktualisierungsoperatoren (z. B. $, $inc ...) usw. können auch als
upsert nach dem Festlegen in der SQL-Aktualisierungsabfrage verstanden werden: Die Bedeutung dieses Parameters besteht darin, ob objNew eingefügt werden soll, wenn kein Aktualisierungsdatensatz vorhanden ist. Der Standardwert ist false und wird nicht eingefügt.
multi: Der Standardwert von mongodb ist „false“. Nur der erste gefundene Datensatz wird aktualisiert. Wenn dieser Parameter „true“ ist, werden alle gemäß den Bedingungen gefundenen Datensätze aktualisiert.

Beispiel:
db.test0.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } ); Ein Datensatz
db.test0.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true ); Alle aktualisiert
db .test0.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false ); Nur der erste wird hinzugefügt
db.test0 .update( { "count" : { $gt : 5 } , { $set : { "test5" : "OK"} },true,true ); Alle hinzugefügt
db.test0 " : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );alle aktualisiert

db.test0.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );Nur das erste Element wird aktualisiert

g) find-Befehl
i. Um Daten abzufragen, kann er mit den Skip- und Limit-Methoden verwendet werden, um Paging-Effekte zu erzielen.
ii. db.[table name].find({}).skip([num1]).limit([num2]), bei welchem ​​Datenelement num1 beginnt, num2 ist die Anzahl der abgefragten Daten, falls Die Daten reichen nicht aus, die verbleibenden Daten haben Vorrang
iii db.[table name].find({[_id:{ < : num }]}) Die Klammern sind Beispiele für Abfragebedingungen, größer als kleiner als und andere Vergleichsoperatoren Verwenden Sie stattdessen Übersetzungszeichen.
> use zm
switched to db zm
> db.zm.find().skip(10).limit(5);
{ "_id" : ObjectId("4e9e3d6b5240000000005a1c"), "char" : "k", "code" : 107 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a1d"), "char" : "l", "code" : 108 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a1e"), "char" : "m", "code" : 109 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a1f"), "char" : "n", "code" : 110 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a20"), "char" : "o", "code" : 111 }
>
h) findOne-Befehl
i. Fragen Sie die angegebene Abfrage ab Die erste Anweisung
ii. db.[table name].findOne()
> db.zm.findOne()
{ "_id" : ObjectId("4e9e3d6b5240000000005a12"), "char" : "a ", "code" : 97 }
Hinweis: Das O in findOne muss großgeschrieben werden.
i) Funktion
i. Benutzerdefinierte Funktion, Sie können sie direkt nach der Definition aufrufen
ii. Funktion testFunction(op1,op2,op3...){}
iii ( op1,op2,op3...){}
iv Die definierte Funktion kann direkt aufgerufen werden und return kann verwendet werden, um Daten zurückzugeben
> function testFunction(){
... db. zm.remove({ "code":{$in:[100,101,102,103]}})
... return db.zm.find({})
... }
> testFunction()
{ "_id" : ObjectId("4e9e3d6b5240000000005a12"), "char" : "a", "code" : 97 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a13"), "char" : "b" , "code" : 98 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a14"), "char" : "c", "code" : 99 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a19") , "char" : "h", "code" : 104 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a1a"), "char" : "i", "code" : 105 }
{ "_id " : ObjectId(" 4e9e3d6b5240000000005a1b"), "char" : "j", "code" : 106 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a1c"), "char" : "k", "code" : 107 } "m", " code" : 109 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a1f"), "char" : "n", "code" : 110 }
{ "_id" : ObjectId(" 4e9e3d6b5240000000005a20"), " char" : "o", "code" : 111 { "_id" : ObjectId("4e9e3d6b5240000000005a22"), "char" : "q", "code" : 113 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a23"), "char" : "r", " Code" : 114 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a24"), "char" : "s", "code" : 115 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a25"), " char": "t", "code": 116 }
{ "_id": ObjectId("4e9e3d6b5240000000005a26"), "char": "u", "code": 117 }
{ "_id": ObjectId("4e9e3d6b5240000000005a27" ), "char" : "v", "code" : 118 }
{ "_id" : ObjectId("4e9e3d6b5240000000005a28"), "char" : "w", "code" : 119 }
{ " _id" : ObjectId("4e9e3d6b5240000000005a29"), "char" : "x", "code" : 120 }
hat mehr
j) var
i. Variablenbenennungstyp
ii. Das Gleiche wie JS Das Gleiche wie var in .
1. Die Benennung von var [name] stimmt auch mit den Benennungsregeln für js-Variablen überein.
k) Druckbefehl
i. Wird zum Drucken verwendet
ii. print([Strings]);
iii Wenn es sich bei dem Druckobjekt um Mongo-Daten handelt, werden diese nicht erkannt.
l) printJson-Befehl
i
auf admin umgestellt
>db.shutdownServer();
Server sollte ausgefallen sein...
MongoDB unterstützt verschiedene bedingte Operatoren, darunter:
? $lt (weniger als)
? $lte (kleiner als oder gleich)
? $gte (größer als oder gleich)
(übereinstimmend mit allen Werten im Array)
? $exists (überprüfen: Existiert das Feld)
? $ne (nicht gleich)
(entspricht einem oder mehreren Werten im Array)
? $nin (entspricht einem oder mehreren Werten im Array)
? $or (entspricht der einen oder anderen Abfrage)
? >? $size (entspricht einem beliebigen Array mit einer vorgegebenen Anzahl von Elementen)
? $type (übereinstimmt Werte mit dem angegebenen BSON-Datentyp)
? name.find({Feldname:{$gt:100}})
mongodb-Update-Operator:

1) $inc

Verwendung: { $inc: { Feld: Wert} }

bedeutet das Hinzufügen eines Werts zu einem numerischen Feld, zum Beispiel:

> db.test0.find( { "_id" : 15 } );
{ "_id" : { " floatApprox" : 15 }, "count" : 16, "test1" : "TESTTEST", "test2" : "OK", "test3" : "TESTTEST", "test4" : "OK", "test5" : "OK " }

> db.test0.update( { "_id" : 15 } , { $inc : { "count" : 1 } } );
> db.test0.find( { "_id" : 15 } ) ;
{ "_id" : { "floatApprox" : 15 }, "count" : 17, "test1" : "TESTTEST", "test2" : "OK", "test3" : "TESTTEST", "test4" : "OK", "test5" : "OK" }

> db.test0.update( { "_id" : 15 } , { $inc : { "count" : 2 } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 19, "test1" : "TESTTEST", "test2" : "OK", "test3" : "TESTTEST", "test4" : "OK", "test5" : "OK" }

> db.test0.update( { "_id" : 15 } , { $inc : { "count" : -1 } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, „count“: 18, „test1“: „TESTTEST“, „test2“: „OK“, „test3“: „TESTTEST“, „test4“: „OK“, „test5“: „OK“ }

2) $set

Verwendung: { $set : { field : value } }

entspricht SQLs set field = value und alle Datentypen unterstützen $set . Beispiel:
> db.test0.update( { "_id" : 15 } , { $set : { "test1" : "testv1", "test2" : "testv2", "test3" : "testv3", test4" : "testv4" } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18 , „test1“ : „testv1“, „test2“ : „testv2“, „test3“ : „testv3“, „test4“ : „testv4“, „test5“ : „OK“ }

3) $ unset

Verwendung: { $unset : { field : 1} }

Wie der Name schon sagt, löscht es das Feld. Beispiel:
> db.test0.update( { "_id" : 15 } , { $unset : { "test1":1 } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test2" : "testv2", "test3" : "testv3", "test4" : "testv4", " test5" : "OK" }

> db.test0.update( { "_id" : 15 } , { $unset : { "test2": 0 } } );
> db.test0. find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test3" : "testv3", "test4" : "testv4", " test5" : "OK" }

> db.test0.update( { "_id" : 15 } , { $unset : { "test3":asdfasf } } );
Fr 14. 16. Mai: 17:38 JS-Fehler: ReferenceError: asdfasf ist nicht definiert (Shell):0

> db.test0.update( { "_id" : 15 } , { $unset : { "test3": "test" } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test4" : " testv4", "test5" : "OK" }

Ich sehe nicht, wofür die 1 im Feld: 1 verwendet wird. Wie auch immer, solange da etwas ist, wird es in Ordnung sein.

4) $push
Verwendung: { $push : { field : value } }

Hängen Sie den Wert an das Feld an not Wenn vorhanden, wird ein neuer Array-Typ hinzugefügt. Beispiel:

> db.test0.update( { "_id" : 15 } , { $set : { "test1" : ["aaa","bbb"] } } );
> db .test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ "aaa", "bbb" ], „test4“: „testv4“, „test5“: „OK“ }

> db.test0.update( { „_id“ : 15 } , { $push : { „test1“: „ccc“ } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ " aaa", "bbb", "ccc" ], "test4" : "testv4", "test5" : "OK" }

> db.test0.update( { "_id" : 15 } , { $push : { "test2": "ccc" } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, „count“: 18, „test1“: [ „aaa“, „bbb“, „ccc“ ], „test2“: [ „ccc“ ], „test4“: „testv4“, „test5“: „OK“ }

> db.test0.update( { "_id" : 15 } , { $push : { "test1": ["ddd","eee"] } } );
> db.test0 .find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ "aaa", "bbb", "ccc" , [ "ddd", "eee" ] ], "test2" : [ "ccc" ], "test4" : "testv4", "test5" : "OK" }
5) $pushAll

Verwendung: { $pushAll : { field : value_array } }

Wie $push, außer dass mehrere Werte gleichzeitig an ein Array-Feld angehängt werden können. Beispiel:

> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ „aaa“, „bbb“, „ccc“, [ „ddd“, „eee“ ] ], „test2“ : [ „ccc“ ], „test4“ : „testv4“, „test5“ : „OK“ }

> db.test0.update( { "_id" : 15 } , { $pushAll : { "test1": ["fff","ggg"] } } );
> db.test0 .find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ "aaa", "bbb", "ccc" , [ „ddd“, „eee“ ], „fff“, „ggg“ ], „test2“ : [ „ccc“ ], „test4“ : „testv4“, „test5“ : „OK“ }

6)$addToSet
Verwendung: { $addToSet : { field : value } }

Fügen Sie einen Wert zum Array hinzu und fügen Sie ihn nur hinzu, wenn der Wert nicht im Array enthalten ist. Beispiel:
> db.test0.update( { "_id" : 15 } , { $addToSet : { "test1": {$each : ["444","555"] } } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [
"aaa",
"bbb",
"ccc",
[
"ddd",
"eee"
],
"fff",
"ggg",
[
"111",
"222"
],
"444",
"555"
], "test2" : [ "ccc" ], "test4" : "testv4", "test5" : "OK" }
> db.test0.update( { "_id" : 15 } , { $addToSet : { "test1": {$each : ["444 ","555"] } } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1": [
"aaa",
"bbb",
"ccc",
[
"ddd",
"eee"
],
"fff",
"ggg",
[
"111",
"222"
],
"444",
"555"
], "test2" : [ "ccc" ], "test4" : "testv4", "test5" : "OK" }
> db.test0.update( { "_id" : 15 } , { $ addToSet : { "test1": ["444","555"] } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox " : 15 }, "count" : 18, "test1" : [
"aaa",
"bbb",
"ccc",
[
"ddd",
"eee"
],
"fff",
"ggg",
[
"111",
"222"
],
"444 ",
"555",
[
"444",
"555"
]
], "test2" : [ "ccc" ], "test4" : " testv4", "test5" : "OK" }
> db.test0.update( { "_id" : 15 } , { $addToSet : { "test1": ["444","555"] } } ) ;
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [
„aaa“,
“bbb“,
“ccc“,
[
“ddd“,
“eee“
],
“fff“,
"ggg",
[
"111",
"222"
],
"444",
"555",
[
"444" ,
"555"
]
], "test2" : [ "ccc" ], "test4" : "testv4", "test5" : "OK" }

7) $pop

Einen Wert im Array löschen

Verwendung:
Letzten Wert löschen: { $pop : { field : 1 } }
Den ersten löschen Wert: { $pop : { field : -1 } }

Beachten Sie, dass nur ein Wert gelöscht werden kann, d. h. nur 1 oder -1 kann verwendet werden, 2 oder -2 jedoch nicht um zwei Werte zu löschen. Es können nur Mongodb 1.1 und höhere Versionen verwendet werden, zum Beispiel:
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count " : 18, "test1" : [
"bbb",
"ccc",
[
"ddd",
"eee"
],
"fff " ,
"ggg",
[
"111",
"222"
],
"444"
], "test2" : [ "ccc" ] , "test4" : "testv4", "test5" : "OK" }
> db.test0.update( { "_id" : 15 } , { $pop : { "test1": -1 } } ) ;
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [
" ccc",
[
"ddd",
"eee"
],
"fff",
"ggg",
[
"111" ,
"222"
],
"444"
], "test2" : [ "ccc" ], "test4" : "testv4", "test5" : "OK" }
> db.test0.update( { "_id" : 15 } , { $pop : { "test1": 1 } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ "ccc", [ "ddd", "eee" ], "fff", "ggg", [ " 111", "222" ] ], "test2" : [ "ccc" ], "test4" : "testv4",
"test5" : "OK" }

8) $pull

Verwendung: $pull : { field : value } }

Löschen Sie einen Wert gleich value aus dem Array-Feld. Beispiel:
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ "ccc ", [ "ddd", "eee" ], "fff", "ggg", [ "111", "222" ] ], "test2" : [ "ccc" ], "test4" : "testv4",
"test5" : "OK" }

> db.test0.update( { "_id" : 15 } , { $pull : { "test1": "ggg" } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ "ccc", [ "ddd ", "eee" ], "fff", [ "111", "222" ] ], "test2" : [ "ccc" ], "test4" : "testv4", "test5"
: "OK" }

9) $pullAll

Verwendung: { $pullAll : { field : value_array } }

Wie bei $pull können Sie mehrere Werte im Array löschen auf einmal. Beispiel:
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ "ccc ", [ "ddd", "eee" ], "fff", [ "111", "222" ] ], "test2" : [ "ccc" ], "test4" : "testv4", "test5"
: "OK" }

> db.test0.update( { "_id" : 15 } , { $pullAll : { "test1": [ "ccc" , "fff" ] } } );
> db.test0.find( { "_id" : 15 } );
{ "_id" : { "floatApprox" : 15 }, "count" : 18, "test1" : [ [ "ddd", „eee“ ], [ „111“, „222“ ] ], „test2“ : [ „ccc“ ], „test4“ : „testv4“, „test5“ : „OK“ }

10) $-Operator

$ ist seine eigene Bedeutung, die ein Element im Array darstellt, das er basierend auf Bedingungen gefunden hat.
> t.find()
{ "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", "comments" : [ { "by" : "joe", "votes" : 3 }, { "by" : "jane", "votes" : 7 } ] }

> t.update( {'comments.by':'joe'}, {$inc:{'comments .$.votes':1}}, false, true )

> t.find()
{ "_id" : ObjectId("4b97e62bf1d8c7152c9ccb74"), "title" : "ABC", " Kommentare“ : [ { „by“ : „joe“, „votes“ : 4 }, { „by“ : „jane“, „votes“ : 7 } ] }

Es ist zu beachten, dass $ nur das erste gefundene Array-Element anwendet und der Rest ignoriert wird. Schauen wir uns das Beispiel an:

> t.find();
{ "_id" : ObjectId("4b9e4a1fc583fa1c76198319"), "x" : [ 1, 2, 3, 2 ] }
> t.update({x: 2}, {$inc: {"x.$": 1}}, false, true);
> t.find();

Etwas anderes Zu beachten: Wenn $ mit $unset verwendet wird, bleibt ein Null-Array-Element übrig, Sie können jedoch {$pull:{x:null}} verwenden, um alle Null-Array-Elemente zu löschen. Beispiel:
> t.insert({x: [1,2,3,4,3,2,3,4]})
> t.find()
{ "_id" : ObjectId ("4bde2ad3755d00000000710e"), "x" : [ 1, 2, 3, 4, 3, 2, 3, 4 ] }
> t.update({x:3}, {$unset:{"x. $":1}})
> t.find()
{ "_id" : ObjectId("4bde2ad3755d00000000710e"), "x" : [ 1, 2, null, 4, 3, 2, 3, 4 ] 🎜>

{ "_id" : ObjectId("4b9e4a1fc583fa1c76198319"), "x" : [ 1, 3, 3, 2 ] }
Indexerstellung in Mongodb:
db.[table name].ensureIndex( { num1: 1, num2:-1}) num1 und num2 sind die Felder für die Indizierung
Beim Erstellen eines Index müssen Sie die folgenden Fragen berücksichtigen:
(1). Welche Schlüssel müssen indiziert werden?
(2). Welche Indexrichtung hat jeder Schlüssel?
(3). Wie gehe ich mit der Erweiterung um? Gibt es eine andere Anordnung der Schlüssel, die mehr häufig verwendete Daten im Speicher behalten würde?
db.[table name].ensureIndex({num1: 1,num2:-1},{"background":true})//Ändern Sie den langjährigen Index
db.runCommand({"dropIndexes": „foo“, „index“: „alphabet“})
Wenn Sie alle Indizes löschen möchten, können Sie * den Wert von „index“ zuweisen.
Master-Slave-Replikation in Mongodb
Master-Slave-Replikation kann für Datenbanksicherung, Fehlerwiederherstellung, Leseerweiterung usw. verwendet werden. (Derzeit gibt es keinen Mechanismus zur Replikation von Slave-Knoten).
1. Führen Sie mongod –master aus, um den Master-Server zu starten.
2. Führen Sie mongod –slave –source master_address aus, um den Slave-Server zu starten. (master_address ist die Adresse des Masterknotens)
3. Erstellen Sie ein Verzeichnis für den Masterknoten und binden Sie den Port (10000):
$mkdir –p ~/dbs/master
$ ./mongod – dbpath ~/ dbs/master –port 10000 –master
4. Legen Sie das Slave-Knotenverzeichnis fest (wählen Sie ein anderes Verzeichnis und einen anderen Port)
$mkdir –p ~/dbs/slave
$ ./mongod –dbpath ~/dbs/ Slave –port 10001 –slave –source
localhost: 10000
Option: -only (angeben, dass nur eine bestimmte Datenbank vom Slave-Knoten kopiert werden soll)
-slavedelay (wird auf dem Slave-Knoten verwendet, beim Anwenden des Master-Knotens Verzögerung während des Betriebs hinzufügen)
-fastsync (Slave-Knoten basierend auf dem Daten-Snapshot des Master-Knotens starten und Master-Slave-Synchronisation implementieren)
-autoresync (Master-Slave-Synchronisation automatisch fortsetzen)
-oplogSize (Master-Knoten-Oplog Die Größeneinheit ist MB)
3. GridFS von Mongodb
Da Mongodb große Datenspeicherung unterstützt, verfügt Mongodb auch über ein verteiltes Dateisystem, GirdFS, das große Datenspeicherung unterstützen kann. In Mongodb gibt es auch ein BSON-Dokumentobjekt mit einer maximalen Größe von 4 MB . Selbst ohne Größenbeschränkungen kann BSON keine schnellen Bereichsabfragen für große Datenmengen erfüllen, daher führte mongodb GridFS ein.
4. Test mit Code in PHP:
MongoDB ist wie MySQL in Form einer PHP-Erweiterungsbibliothek .dll in PHP integriert.
Gehen Sie auf die folgende Website, um die DLL-Datei der entsprechenden PHP-Version unter Windows herunterzuladen:
http://cn.php.net/manual/en/mongo.installation.php#mongo.installation.windows
Entsprechend Ihrer eigenen PHP-Version, ob sie threadsicher ist (kann in phpinfo überprüft werden) usw. Wählen Sie die entsprechende Version zum Herunterladen aus, entpacken Sie sie und erhalten Sie die Datei php_mongo.dll. Kopieren Sie es in das ext-Verzeichnis im PHP-Installationsverzeichnis. Hinzufügen: extension = php_mongo.dll;
Starten Sie den Webserver (Apache oder Nginx) in der Datei php.ini neu. Sie sollten mingoDB-Informationen in phpinfo sehen können, andernfalls liegt ein Installationsproblem vor. Möglicherweise ist die heruntergeladene mingoDB-Erweiterung falsch.
Php betreibt mongodb
1. Stellen Sie eine Verbindung mit mongoDB her:
Instanziieren Sie direkt die Mongo-Klasse, um eine Verbindung zu erstellen:
$mo = new Mongo(); // Holen Sie sich ein Mongo-Verbindungsobjekt
Instanziieren Erstellen Sie eine Mongo-Klasse und stellen Sie eine Verbindung mit dem Standardport „localhost:27017“ mongoDB her.
Wenn Sie eine Verbindung zu anderen Hosts herstellen möchten, können Sie Folgendes schreiben:
$mongo = new Mongo("mongodb://username:password@192.168.1.22:12345");
Andere Möglichkeit, Beispiel Verwandeln Sie die Mongo-Klasse in eine Mongo-Klasse und stellen Sie dann manuell eine Verbindung her:
$mongo= newMongo("mongodb://username:password@192.168.1.22:12345",array('connect'=>false)) ;//Initialisierungsklasse
$mongo->connect();//Eine Verbindung erstellen
Einige nützliche Methoden in der Mongo-Klasse:
Mongo::listDBs()
Gibt eine Datenbank zurück, die die Datenbank enthält ( DB) Informationen zum aktuellen Mongo-Service-Array.
$mo = new Mongo();
$dbs = $mo->listDBs();//Erhalten Sie ein Array mit Datenbankinformationen
Mongo::selectCollection($db,$coll)
Gibt ein Sammlungsobjekt in einer bestimmten Datenbank unter der aktuellen Verbindung zurück.
$mo = new Mongo();
$coll = $mo->selectCollection('db','mycoll');//Ein Sammlungsobjekt abrufen
Wählen Sie die gewünschte Datenbank (Mongo-Klasse) aus:
Eine Möglichkeit:
$mongo = new Mongo();
$db = $mongo->foo;//Ein MongoDB-Objekt abrufen
Eine andere Möglichkeit:
$mongo = new Mongo( );
$db = $mongo->selectDB('foo');//Ein MongoDB-Objekt abrufen
Nützliche Funktionen in MongoDB:
Ein MongoDB-Objekt erstellen
$mo = new Mongo() ;
$db = new MongoDB($mo,'dbname');//Erhalten Sie ein MongoDB-Objekt durch Erstellung
Löschen Sie die aktuelle Datenbank
$db = $mo->dbname; ->drop();
Den aktuellen Datenbanknamen abrufen
$db = $mo->dbname;
$db->_tostring();
Wählen Sie die gewünschte Sammlung aus:
A:
$mo = new Mongo();
$coll = $mo->dbname->collname;//Ein Sammlungsobjekt abrufen
B:
$db = $mo ->selectDB(' dbname');
$coll = $db->collname;
C:
$db = $mo->dbname;
$coll = $db->selectCollectoin( 'collname'); //Erhalte ein Sammlungsobjekt
Daten einfügen (MongoCollection-Objekt):
MongoCollection::insert(array $a,array $options)
array $a Das einzufügende Array
array $options Optionen
sicher, ob das Operationsergebnis zurückgegeben werden soll Informationen
Ob fsync direkt in die physische Festplatte eingefügt wird

$coll = $mo->db->foo;
$a = array('a'=>'b');
$options = array('safe'=>true);
$rs =$coll->insert($a,$options);
$rs ist ein Array vom Typ Array, das Operationsinformationen enthält
Datenbankeinträge löschen in (MongoCollection-Objekt):
MongoCollection::remove(array $criteria,array $options)
array $criteria Conditions
array $options Options
safe Gibt an, ob der Vorgang zurückgegeben werden soll Ergebnis
fsync Ob es sich direkt auf die physische Festplatte auswirkt
justOne ob es nur einen Datensatz betrifft

$coll = $mo->db->coll;
$c = array(' a'=>1,' s'=>array('$lt'=>100));
$options = array('safe'=>true);
$rs = $coll->remove ($c,$options) ;
$rs ist ein Array vom Typ Array, das Operationsinformationen enthält
Datensätze in der Datenbank aktualisieren (MongoCollection-Objekt):
MongoCollection::update(array $criceria,array $newobj ,array $options)
array $criteria Conditions
array $newobj Zu aktualisierender Inhalt
array $options Options
sicher, ob das Operationsergebnis zurückgegeben werden soll
fsync, ob es sich direkt auf die physische Festplatte auswirkt disk
Upsert, ob keine passenden Daten vorhanden sind. Fügen Sie einfach ein neues
Multiple hinzu, um zu sehen, ob es alle Datensätze betrifft, die die Bedingungen erfüllen. Standardmäßig betrifft es nur einen

$coll = $mo-. >db->coll;
$c = array('a' =>1,'s'=>array('$lt'=>100));
$newobj = array('e'= >'f','x'=>'y');
$options = array('safe'=>true,'multiple'=>true);
$rs = $coll->remove( $c,$newobj,$options);
$rs ist ein Array vom Array-Typ, das Operationsinformationen enthält
Sammlung abfragen, um einen einzelnen Datensatz zu erhalten (MongoCollection-Klasse):
array MongoCollection::findOne(array $query,array $fields)
array $query Condition
array $fields Zu erhaltende Felder

$coll = $mo->db->coll;
$query = array(' s'=>array('$lt'=>100));
$fields = array('a'=>true,'b'=>true);
$rs = $coll->findOne ($query,$fields);
Wenn es ein Ergebnis gibt, geben Sie ein Array zurück, wenn es kein Ergebnis gibt, geben Sie NULL zurück
Abfragesammlung, um mehrere Datensätze zu erhalten (MongoCollection-Klasse):
MongoCursor MongoCollection:: find(array $query,array $fields)
array $query-Bedingung
array $-Felder Zu erhaltende Felder

$coll = $mo->db->coll;
$query = array('s'=>array('$lt'=>100));
$fields = array('a'=>true,'b'=>true);
$cursor = $coll ->find($query,$fields);
Gibt ein Cursor-Datensatzobjekt MongoCursor zurück.