Länka och skapa MongoDB-anslutningar med SQL:Del 1

SQL är det mest föredragna sättet att engagera relationsdatabaser när det gäller frågor. Det är underförstått att användare skulle ha arbetat med relationsdatabaser som MySQL och PostgreSQL som använder SQL-frågefunktionen. Generellt sett är SQL lätt att förstå och blev därför flitigt använt särskilt i relationsdatabaser.

SQL är dock ganska komplicerat när man försöker engagera en bred uppsättning dokument i en databas. I ett nötskal är den inte avsedd för dokumentdatabaser eftersom den kommer med ett antal bakslag. Till exempel kan du inte enkelt fråga inbäddade arraydokument eller snarare måste du designa ett underprogram för att iterera och filtrera returnerad data för att ge önskade resultat. Följaktligen kommer detta att resultera i en ökning av exekveringstiden. Men att ha en god förståelse för SQL kommer att ge en bättre grund för att interagera med MongoDB från någon punkt snarare än att börja från början.

I den här bloggen kommer vi att använda Studio 3T-programmet för att visa de olika SQL-anslutningsfrågorna och hur du kan designa om dem till MongoDB-frågor för att uppnå bättre prestanda. Programmet kan laddas ner från denna länk.

Ansluter SQL till MongoDB

Det finns flera drivrutiner eller snarare gränssnitt genom vilka du kan använda SQL för att kommunicera med MongoDB, till exempel ODBC. ODBC står för Open Database Connectivity. Detta är helt enkelt ett gränssnitt som gör att applikationer kan komma åt data i databashanteringssystem med SQL som standardprocess för åtkomst till dessa data. Den kommer med en extra driftskompatibilitetsfördel där en enda applikation kan komma åt flera databashanteringssystem.

I den här bloggen kommer vi att producera och testa kod från SQL och sedan optimera den via en aggregeringsredigerare för att producera en MongoDB-fråga.

Mappningsdiagram för SQL till MongoDB

Innan vi går in på mycket detaljer måste vi förstå de grundläggande relationerna mellan dessa två databaser, särskilt nyckelord i frågekonceptet.

Terminologi och begrepp

SQL	MongoDB
Tabell Rad Kolumn Tabellkopplingar	Samling BSON-dokument Fält $lookup

Primärnyckeln i SQL definierar en unik kolumn som i princip ordnar raderna i ordning efter rekordtid. Å andra sidan är primärnyckeln i MongoDB ett unikt fält för att hålla ett dokument och säkerställa att indexerade fält inte lagrar dubbletter av värden.

Severalnines Become a MongoDB DBA - Bringing MongoDB to ProductionLäs om vad du behöver veta för att distribuera, övervaka, hantera och skala MongoDBDownload gratis

Korrelation mellan SQL och MongoDB

Låt oss säga att vi har studentdata och vi vill registrera dessa data i både SQL-databas och MongoDB. Vi kan definiera ett enkelt elevobjekt som:

{
    name: ‘James Washington’,
    age: 15,
    grade: A,
    Score: 10.5
}

När vi skapar en SQL-tabell måste vi definiera kolumnnamn och datatyp medan i MongoDB en samling automatiskt skapas under den första infogningen.

Tabellen nedan hjälper oss att förstå hur en del av SQL-satsen kan skrivas i MongoDB.

SQL-schemasats MongoDB Schema Statements

SQL-schemasats	MongoDB Schema Statements
`CREATE TABLE students ( id MEDIUMINT NOT NULL AUTO_INCREMENT, name Varchar (30), age Number, score Float )` För att infoga ett dokument i databasen `INSERT INTO students(Name, age, grade,score) VALUES(“James Washington”, 15, “A”, 10.5)`	Vi kan definiera en schemadesign med hjälp av vissa moduler som mongoose och definiera fälten som ett objekt istället för att infoga ett dokument direkt för att visa korrelationen. Det primära arkiverade ID:t kommer att genereras automatiskt under infogningen av ett dokument. `{ name: String, age Number, score: Number }` Infogar ett nytt dokument för att skapa samlingen `db.students.insertOne({ name: ‘James Washington’, age: 15, grade: ‘A’, score: 10.5 })`
Använd ADD-satsen för att lägga till en ny kolumn i den befintliga tabellen. `ALTER TABLE students ADD units 10`	Strukturen för insamlingsdokument är inte väldefinierad och uppdaterar därför dokument på dokumentnivå med hjälp av updateMany() `db.students.updateMany({}, {$set: {units: 10}})`
För att ta bort en kolumn (enheter) `ALTER TABLE students DROP COLUMN units`	För att släppa ett fält (enheter) `db.students.updateMany({}, {$unset: {units: “”}})`
Att släppa ett bord studenter `DROP TABLE students`	Att lämna insamlingsstudenter `db.students.drop()`

CREATE TABLE students (
  id MEDIUMINT NOT NULL AUTO_INCREMENT,
  name Varchar (30),
  age Number,
  score Float
)

För att infoga ett dokument i databasen

INSERT INTO students(Name, age, grade,score) VALUES(“James Washington”, 15, “A”, 10.5)

Vi kan definiera en schemadesign med hjälp av vissa moduler som mongoose och definiera fälten som ett objekt istället för att infoga ett dokument direkt för att visa korrelationen. Det primära arkiverade ID:t kommer att genereras automatiskt under infogningen av ett dokument.

{
  name: String,
  age Number,
  score: Number
}

Infogar ett nytt dokument för att skapa samlingen

db.students.insertOne({
    name: ‘James Washington’,
    age: 15,
    grade: ‘A’,
    score: 10.5
})

Använd ADD-satsen för att lägga till en ny kolumn i den befintliga tabellen.

ALTER TABLE students ADD units 10

Strukturen för insamlingsdokument är inte väldefinierad och uppdaterar därför dokument på dokumentnivå med hjälp av updateMany()

db.students.updateMany({}, {$set: {units: 10}})

För att ta bort en kolumn (enheter)

ALTER TABLE students DROP COLUMN units

För att släppa ett fält (enheter)

db.students.updateMany({}, {$unset: {units: “”}})

Att släppa ett bord studenter

DROP TABLE students

Att lämna insamlingsstudenter

db.students.drop()

SQL Select-sats MongoDB hitta uttalanden

SQL Select-sats	MongoDB hitta uttalanden
Markera alla rader `SELECT * FROM students`	Välj alla dokument `db.students.find()`
För att endast returnera specifika kolumner. `SELECT name, grade FROM students`	För att endast returnera specifika fält. Som standard returneras _id-fältet om inte annat anges i projektionsprocessen. `db.students.find({}, {name: 1, grade: 1, _id: 0})` Om du ställer in _id:0 betyder det att endast det returnerade dokumentet endast kommer att ha namnet och betygsobjektets värden.
För att välja specifika rad(er) med något matchande kolumnvärde. `SELECT * FROM students WHERE grade = “A”`	För att välja specifika dokument med något matchande fältvärde. `db.students.find({grade: “A”})`
Välja rader med en kolumn vars värden har några tecken som det angivna kriterievärdet `SELECT * FROM students WHERE name like “James%”`	Välja dokument med ett fält vars värden har några tecken som det angivna kriterievärdet `db.students.find({grade: {$regex: /^James/}})`
För att returnera raderna i stigande ordning med hjälp av primärnyckeln. `SELECT * FROM students ORDER BY id ASC`	För att returnera dokumenten i stigande med hjälp av primärnyckeln `db.students.find().sort({$natural: 1})`
Att gruppera returnerade rader i enlighet med någon kolumn (betyg) `SELECT DISTINCT (grade) FROM students`	Att gruppera returnerade dokument i enlighet med något fält (betyg) `db.students.aggregate([ {$group: : {_id: “$grade”}} ]`
Begränsa antalet returnerade rader och hoppa över några `SELECT * FROM students LIMIT 1 SKIP 4`	Begränsning av antalet returnerade dokument och hoppar över rader `db.students.find.limit(1).skip(4)`
Ett viktigt alternativ är att veta hur vår fråga exekveras och använd därför förklara-metoden. `EXPLAIN SELECT * FROM students WHERE grade “A”`	`db.students.find({grade: “A”}).explain()`

Markera alla rader

SELECT * FROM students

Välj alla dokument

db.students.find()

För att endast returnera specifika kolumner.

SELECT name, grade FROM students

För att endast returnera specifika fält. Som standard returneras _id-fältet om inte annat anges i projektionsprocessen.

db.students.find({}, {name: 1, grade: 1, _id: 0})

Om du ställer in _id:0 betyder det att endast det returnerade dokumentet endast kommer att ha namnet och betygsobjektets värden.

För att välja specifika rad(er) med något matchande kolumnvärde.

SELECT * FROM students WHERE grade = “A”

För att välja specifika dokument med något matchande fältvärde.

db.students.find({grade: “A”})

Välja rader med en kolumn vars värden har några tecken som det angivna kriterievärdet

SELECT * FROM students WHERE name like  “James%”

Välja dokument med ett fält vars värden har några tecken som det angivna kriterievärdet

db.students.find({grade: {$regex: /^James/}})

För att returnera raderna i stigande ordning med hjälp av primärnyckeln.

SELECT * FROM students ORDER BY id ASC

För att returnera dokumenten i stigande med hjälp av primärnyckeln

db.students.find().sort({$natural: 1})

Att gruppera returnerade rader i enlighet med någon kolumn (betyg)

SELECT DISTINCT (grade) FROM students

Att gruppera returnerade dokument i enlighet med något fält (betyg)

db.students.aggregate([
{$group: : {_id: “$grade”}}
]

Begränsa antalet returnerade rader och hoppa över några

SELECT * FROM students LIMIT 1 SKIP 4

Begränsning av antalet returnerade dokument och hoppar över rader

db.students.find.limit(1).skip(4)

Ett viktigt alternativ är att veta hur vår fråga exekveras och använd därför förklara-metoden.

EXPLAIN SELECT *  FROM students WHERE grade “A”

db.students.find({grade: “A”}).explain()

SQL Update-sats MongoDB-uppdateringsutlåtanden

SQL Update-sats	MongoDB-uppdateringsutlåtanden
Uppdatera betygskolumnen för elever vars ålder är lika med 15 år eller äldre `UPDATE students SET grade = “B” WHERE age >= 15`	Här använder vi några operatorer som $gt, $lt och $lte. `db.students.updateMany({age: {$gte: 15}}, {$set: {status: “B”}})`
Ökar något kolumnvärde `UPDATE students SET age = age + 1 WHERE age < 15`	`db.students.updateMany({ age: {$lt:15}},{$inc: {age: 1}})`

Uppdatera betygskolumnen för elever vars ålder är lika med 15 år eller äldre

UPDATE students SET grade  = “B” WHERE age >= 15

Här använder vi några operatorer som $gt, $lt och $lte.

db.students.updateMany({age: {$gte: 15}}, {$set: {status: “B”}})

Ökar något kolumnvärde

UPDATE students SET age  = age + 1 WHERE age < 15

db.students.updateMany({
age: {$lt:15}},{$inc: {age: 1}})

SQL delete-sats MongoDB tar bort uttalanden

SQL delete-sats	MongoDB tar bort uttalanden
För att radera alla rader `DELETE FROM students`	För att radera alla dokument. `db.students.remove({})`
För att ta bort en specifik rad där någon kolumn har ett specifikt värde. `DELETE FROM students WHERE age = 15`	`db.students.remove({age: 15})`

För att radera alla rader

DELETE FROM students

För att radera alla dokument.

db.students.remove({})

För att ta bort en specifik rad där någon kolumn har ett specifikt värde.

DELETE FROM students WHERE age = 15

db.students.remove({age: 15})

Med den här exempelmappningstabellen kan du få en bättre förståelse för vad vi ska lära dig i nästa ämne.

SQL och Studio 3T

Studio 3T är ett av de tillgängliga programmen som hjälper till att koppla ihop SQL och MongoDB. Den har en SQL Query-funktion för att förbättra en för att manipulera SQL. Frågan tolkas till Mongo-skal för att producera en enkel frågekod i MongoDB-språkmotsvarighet. Förutom att göra enkla frågor kan Studio 3T-applikationen nu göra joins.

För våra exempeldata ovan, efter att ha anslutit din databas i Studio 3T, kan vi använda SQL-fönstret för att hitta dokumentet som matchar våra kriterier, dvs.:

SELECT * FROM students  WHERE name LIKE  'James%';

Om du har ett dokument med namnfältet inställt på värdet James, kommer det att returneras. På samma sätt, om du klickar på frågekodfliken, kommer du att presenteras med ett fönster med motsvarande MongoDB-kod. För uttalandet ovan kommer vi att ha:

db.getCollection("students").find(
    { 
        "name" : /^James.*$/i
    }
);

Sammanfattning

Ibland kanske du vill ha ett snabbt sätt att interagera med MongoDB från den kunskap du har om SQL. Vi har lärt oss några grundläggande kodlikheter mellan SQL och dess motsvarighet i MongoDB. Vidare har vissa program som Studio 3T väletablerade verktyg för att konvertera SQL-frågan till MongoDB-motsvarande språk och finjustera denna fråga för bättre resultat. Tja, för de flesta av oss kommer detta att vara ett bra verktyg för att göra vårt arbete enkelt och säkerställa att den kod vi har i slutändan är mycket optimal för vår databas prestanda. I del 2 av den här bloggen ska vi lära oss om SQL INNER JOIN i MongoDB.