Comparing 30 MongoDB operations with Oracle SQL statements

COMPARING
MONGODB SEARCH
WITH
RACLE SQL QUERIES
MongoDB Find & Aggregate vs
comparable Oracle SQL queries
Lucas Jellema
O

TOPICS
• Filter & Sort (find, sort)
• Aggregation ($group, $project, $match, $sort)
• Lookup & Outer Join ($lookup, $arrayElemAt)
• Facet Search ($facet, $bucket, $sortByCount)
• Update (findAndModify, forEach, save, update, upsert, $set, $unset)
• Date and Time operations
• Materialized View ($out)
• Nested documents/tables ($unwind, $reduce)
• Geospatial (ensureIndex, 2dsphere, $near, $geoNear)
• Text Search (createIndex, text, $text, $search)
• Stored Procedures (db.system.js.save, $where)

DATA SET
• HRM
• Collections emp and dept – JSON documents in MongoDB database
• Tables EMP and DEPT – relational records in Oracle Database

HRM DATA SET
JSON DOCUMENT COLLECTIONS EMP AND DEPT

HRM DATA SET
TABLES EMP AND DEPT

ALL SOURCES ARE AVAILABLE ON GITHUB
• https://github.com/lucasjellema/sig-nosql-mongodb

FIND THE NAMES OF ALL MANAGERS
db.emp.find
( {"JOB":"MANAGER"}
, {ENAME:1}
)
select ename
from emp
Where job = 'MANAGER'

FIND NAME AND SALARY OF SALESMEN ORDERED BY
SALARY FROM HIGH TO LOW
db.emp.find
( {"JOB":"SALESMAN"}
, { ENAME:1
, SAL:1}
)
.sort
( {'SAL':-1})
select ename
, sal
from emp
where job = 'SALESMAN'
order
by sal desc

FIND NAME AND SALARY OF TWO HIGHEST EARNING
SALESMEN – BEST PAID FIRST
db.emp.find
( {"JOB":"SALESMAN"}
, { ENAME:1
, SAL:1}
)
.sort
( {'SAL':-1})
.limit(2)
select ename
, sal
from emp
where job = 'SALESMAN'
order
by sal desc
FETCH FIRST 2 ROWS ONLY

FIND EMPLOYEES WITH ‘AR’ IN THEIR NAME – IN
ALPHABETICAL ORDER BY NAME
db.emp.find
( {"ENAME":{$regex: "AR"} }
, { ENAME:1
, SAL:1}
)
.sort
( {'ENAME':1})
select ename
, sal
from emp
where ename like '%AR%'
order
by ename

FIND EMPLOYEES NOT IN DEPARTMENT 10, NAME AND
SALARY AND SORTED ALPHABETICALLY BY NAME
db.emp.find
( { "DEPTNO":{$ne: 10} }
, { ENAME:1
, SAL:1
, DEPTNO:1
}
)
.sort
( {'ENAME':1})
select ename
, sal
, deptno
from emp
where deptno != 10
order
by ename

SET DATE TYPE PROPERTY STARTDATE DERIVED FROM
STRING TYPE PROPERTY HIREDATE
db.emp.find().forEach
( function (elem) {
elem.startdate =
new Date( "19“
+ elem.HIREDATE.substring(6)
+ "-"
+ elem.HIREDATE.substring(3,5)
+ "-"
+ elem.HIREDATE.substring(0,2)
);
db.emp.save(elem);
}
)
alter table emp
add (startdate date)
update emp
set startdate =
to_date( hiredate, 'DD-MM-RR')

FIND SALESMEN WITH A TOTAL INCOME HIGHER THAN 2000
-- use $where with embedded JavaScript
db.emp.find
( {"JOB":"SALESMAN"
, $where :
" this.SAL +
(this.COMM != null? this.COMM: 0)
> 2000"
}
)
select *
from emp
where sal + nvl(comm, 0) > 2000

CREATE STORED FUNCTION SALARY CAP TO RETURN MAX SALARY PER
JOB; USE SALARY CAP TO FIND EMPLOYEES EARNING OVER THEIR CAP
db.system.js.save({
"_id": "salaryCap",
"value": function(job) {
return job=='CLERK'?1000
:(job=='ANALYST'?3500
:(job=='SALESMAN'?2000
:(job=='MANAGER'?3000
:10000
)));
}
})
-- load function in current database
db.loadServerScripts();
db.emp.find(
{ $where : " this.SAL >
salaryCap(this.JOB)"}
, {ENAME:1, SAL:1, JOB:1})
create or replace
function salary_cap
(p_job in varchar2)
return number
is
begin
return
case p_job
when 'CLERK' then 1000
when 'ANALYST' then 3500
when 'SALESMAN' then 2000
when 'MANAGER' then 3000
else 10000
end;
end salary_cap;
select ename
, sal
, job
from emp
where sal > salary_cap( job)

SELECT NAME, STARTMONTH AND STARTYEAR FOR ALL
EMPLOYEES
db.emp.aggregate(
[{$project: {
"ENAME": 1,
"startmonth": { $month: "$startdate"},
"startyear": { $year: "$startdate"}
}
}
]
)
select ename
, extract (month from startdate)
as startmonth
, extract (year from startdate)
as startyear
from emp

TOTAL SALARY SUM, TOTAL NUMBER OF EMPLOYEES, THE
HIGHEST SALARY AND THE EARLIEST STARTDATE
db.emp.aggregate(
[{$group: {
_id: null,
total_salary_sum: { $sum: "$SAL" },
total_staff_count: { $sum: 1 },
max_sal: { $max: "$SAL" },
min_startdate: { $min: "$startdate" }
}
}
]
)
select sum(sal) total_salary_sum
, count(*) total_staff_count
, max(sal) max_sal
, min(startdate) min_startdate
from emp

TOTAL SALARY SUM, TOTAL NUMBER OF EMPLOYEES, THE HIGHEST
SALARY AND THE EARLIEST STARTDATE PER DEPARTMENT
db.emp.aggregate(
[{$group: {
_id: "$DEPTNO",
}
}
]
)
select deptno
hireyear
, sum(sal) total_salary_sum
, max(sal) max_sal
from emp
group
by deptno

TOTAL SALARY SUM, NUMBER OF EMPLOYEES, HIGHEST SALARY AND
EARLIEST STARTDATE PER DEPARTMENT AND HIREYEAR
WITH NUMBER OF EMPLOYEES TWO OR MORE
db.emp.aggregate(
[{$group: {
_id: { deptno: "$DEPTNO“
, hireyear :
{ $year: "$startdate"}
},
}
}
,{$match: {
total_staff_count: { $gt: 1 }
}
}
]
)
select deptno
hireyear
, sum(sal) total_salary_sum
, max(sal) max_sal
from emp
having count(*) > 1
group
by deptno

ALL EMPLOYEES WITH THEIR DEPARTMENT DETAILS (WHEN
AVAILABLE)
db.emp.aggregate(
[{$lookup: {
from:"dept",
localField:"DEPTNO",
foreignField:"deptno",
as:"dept"
}
,{$project: {
"EMPNO": 1,
"ENAME": 1,
"DEPT": { $arrayElemAt:["$dept", 0]}
}
}
]
)
select e.*
, d.*
from emp e
left outer join
dept d
on (e.deptno = d.deptno)

ALL DEPARTMENTS WITH A LIST OF THE NAMES OF THEIR EMPLOYEES
db.dept.aggregate(
[{$lookup: {
from:"emp",
localField:"deptno",
foreignField:"DEPTNO",
as:"emps"
}
}
,{$project: {
"deptno": 1,
"dname": 1,
"staff": {
$reduce: {
input: "$emps",
initialValue: "",
in: { $concat : ["$$value"
, ", "
,"$$this.ENAME"]
}
} // reduce
} // staff
} // project
}
])
select d.deptno, d.dname
, listagg( ename, ',')
within group (order by ename)
as "staff"
from dept d
left outer join
emp e
on (d.deptno = e.deptno)
group
by d.deptno
, d.dname

ALL EMPLOYEES WHO WORK IN NEW YORK
db.emp.aggregate(
[{$lookup: {
from:"dept",
localField:"DEPTNO",
foreignField:"deptno",
as:"dept"
}
,{$project: {
"EMPNO": 1,
"ENAME": 1,
"DEPT": { $arrayElemAt:["$dept", 0]}
}
}
, {$match: { "DEPT.loc" :"NEW YORK"} }
]
)
select e.*
, d.*
from emp e
left outer join
dept d
on (e.deptno = d.deptno)
where d.loc = 'NEW YORK'

EMPLOYEE NAMED KING
WITH ALL EMPLOYEES WHO WORK UNDER HER OR HIM
AND A NEAT LIST OF THE NAMES OF THESE SUBORDINATE STAFF
db.emp.aggregate(
[{$match: { ENAME: "KING"}}
,{$lookup: {
from:"emp",
localField:"EMPNO",
foreignField:"MGR",
as:"subordinates"
}
}
,{$project: {
"EMPNO": 1,
"ENAME": 1,
"subordinates": 1,
"staff": { $reduce: {
input: "$subordinates",
initialValue: "",
in: { $concat :
["$$value", ", ","$$this.ENAME"]
} //in
} // reduce
},
}
}
]
)
select e.*
, cursor( select *
from emp s
where s.mgr = e.empno
) subordinates
, ( select listagg( s.ename, ',')
within group
(order by ename)
from emp s
where s.mgr = e.empno
) as "staff"
from emp e
where e.ename = 'KING'

FACET AGGREGATION: # EMPLOYEES BY JOB, BY SALARY BUCKET, BY
DEPARTMENT AND BY STARTDATE (1)
db.emp.aggregate(
[{$facet: {
"categorizedByJob": [
{ $sortByCount: "$JOB" }
],
"categorizedBySalary": [
{$bucket: {
groupBy: "$SAL",
boundaries: [0, 1000, 2000 ,3000 ,10000 ],
default: "Other",
output: {
"count": { $sum: 1 },
"employees": { $push: "$ENAME" }
} // output
}// bucket
}
],
"categorizedByDepartment": [
{ $sortByCount: "$DEPTNO" }
],
"categorizedByHiredate(Auto)": [
{
$bucketAuto: {
groupBy: "$startdate",
buckets: 4
}
}
]
}
}
])
-- categorizedByJob
select job
, count(*) as "count"
from emp
group
by job
order
by "count" desc
-- categorizedByDepartment
select deptno
from emp
group
by deptno
order
by "count" desc

db.emp.aggregate(
[{$facet: {
],
{$bucket: {
groupBy: "$SAL",
boundaries: [0, 1000, 2000 ,3000 ,10000 ],
default: "Other",
output: {
"count": { $sum: 1 },
} // output
}// bucket
}
],
],
{
$bucketAuto: {
buckets: 4
}
}
]
}
}
])
-- categorizedBySalary
with bucket_boundaries as
( select 10000 lower_boundary from dual
union all
select 2000 lower_boundary from dual
union all
union all
)
, buckets as
( select lower_boundary
, lead(lower_boundary) over
(order by lower_boundary)-1 upper_boundary
from bucket_boundaries
)
select lower_boundary
, count(*)
from emp
left outer join
buckets
on (sal between lower_boundary
and upper_boundary)
group
by lower_boundary

db.emp.aggregate(
[{$facet: {
],
{$bucket: {
groupBy: "$SAL",
boundaries: [0, 1000, 2000 ,3000 ,10000 ],
default: "Other",
output: {
"count": { $sum: 1 },
} // output
}// bucket
}
],
],
{
$bucketAuto: {
buckets: 4
}
}
]
}
}
])
-- categorizedByHiredate
with tiled as
( select ename
, startdate
, ntile(4) over (order by startdate asc)
as size_bucket
from emp
)
select size_bucket
, listagg( ename, ',')
within group (order by startdate) employees
from tiled
group
by size_bucket
order
by size_bucket

CREATE MATERIALIZED COLLECTION FROM QUERY
DEPARTMENTS WITH NESTED EMPLOYEES
db.dept.aggregate(
[ {$lookup:
{
from:"emp",
localField:"deptno",
foreignField:"DEPTNO",
as:"emps"
}
}
, {$out: "departments"
}
]
)
create or replace type emp_t as object
( EMPNO NUMBER(4)
, ENAME VARCHAR2(10)
, JOB VARCHAR2(9)
, MGR NUMBER(4)
, SAL NUMBER(7,2)
, COMM NUMBER(7,2)
, STARTDATE DATE
)
create or replace type emp_tbl_t as table of emp_t
-- create materialized view
-- with nested table
create materialized view departments
BUILD IMMEDIATE
REFRESH FORCE
ON DEMAND
as
select deptno
, dname
, loc
, cast ( multiset ( select empno, ename, job
, mgr, sal, comm, hiredate
from emp e
where e.deptno = d.deptno
)
as emp_tbl_t) staff
from dept d

FIND DEPARTMENT THAT CONTAINS EMPLOYEE NAMED KING
FROM DEPARTMENTS COLLECTION WITH NESTED EMPLOYEES
db.departments.find
( {"emps.ENAME":"KING"}
)
select d.deptno
, d.dname
, d.loc
from departments d
where ( select count(*)
from table(d.staff)
where ename ='KING'
) > 0

ONLY FIND EMPLOYEE KING (AND NOT ALL EMPLOYEES IN THE DEPARTMENT)
db.departments.aggregate(
[
{$unwind: {path:"$emps"}}
, {$match: { "emps.ENAME": "KING"}}
, {$project: {
"EMPNO": "$emps.EMPNO",
"JOB": "$emps.JOB",
"ENAME": "$emps.ENAME",
"STARTDATE": "$emps.startdate",
"DNAME": 1
}
}
]
)
select d.deptno
, d.dname
, d.loc
, staff.*
from departments d
, table(d.staff) staff
where staff.ename = 'KING'

FIND NAMES OF ALL MANAGERS
[
, {$match: { "emps.JOB": "MANAGER"}}
, {$project: {
}
}
]
)
select staff.ename
from departments d
where staff.job = 'MANAGER'

FIND ALL EMPLOYEES WHO ARE NOT IN DEPARTMENT 10, WITH THEIR NAME
AND SALARY AND SORTED ALPHABETICALLY BY NAME
[
{$match: { "DEPTNO": {$ne:10}}}
, {$unwind: {path:"$emps"}}
, {$project: {
"SAL": "$emps.SAL",
"DEPTNO": 1,
}
}
, {$sort : {"ENAME":1}}
]
)
select staff.ename
, staff.sal
, d.deptno
from departments d
where d.deptno != 10
order
by staff.ename

TOTAL SALARY SUM, TOTAL NUMBER OF EMPLOYEES, THE HIGHEST SALARY
AND THE EARLIEST STARTDATE, PER DEPARTMENT
[
, {$group:{ _id: '$deptno'
, total_salary_sum : {$sum: "$emps.SAL"}
, total_staff_count : {$sum: 1}
, max_sal : {$max: "$emps.SAL"}
, min_startdate : {$min: "$emps.startdate"}
}
}
]
)
select d.deptno
, sum(staff.sal) total_salary_sum
, count(staff.empno) total_staff_count
, max(staff.sal) max_sal
, min(staff.startdate) min_startdate
from departments d
group
by d.deptno

ADDING GEO LOCATIONS AND CREATE GEO INDEX
db.dept.findAndModify({
query: { loc: "NEW YORK" },
update: { $set: { "location" : {
"type" : "Point",
"coordinates" : [ -73.9352, 40.7306 ]
}
} },
upsert: true
})
query: { loc: "DALLAS" },
"type" : "Point",
"coordinates" : [ -96.8005, 32.7801 ]
}
} },
upsert: true
})
query: { loc: "BOSTON" },
"type" : "Point",
"coordinates" : [ -71.0598, 42.3584 ]
}
} },
upsert: true
})
...
-- create spatial index
db.dept.ensureIndex( { location : "2dsphere" } );
-- add column geo_location to hold SDO_GEOMETRY
alter table dept
add (geo_location SDO_GEOMETRY)
-- add geo location to each department
update dept
set geo_location = SDO_GEOMETRY(2001, 8307,
SDO_POINT_TYPE (-73.935242, 40.730610,NULL)
, NULL, NULL)
where loc = 'NEW YORK'
update dept
set geo_location = SDO_GEOMETRY(2001, 8307,
SDO_POINT_TYPE (-96.8005, 32.7801,NULL), NULL, NULL)
where loc = 'DALLAS'
-- insert dimensional meta information for the spatial column
INSERT INTO USER_SDO_GEOM_METADATA
(TABLE_NAME, COLUMN_NAME, DIMINFO, SRID)
VALUES ('DEPT', 'GEO_LOCATION',
SDO_DIM_ARRAY
(SDO_DIM_ELEMENT('LONG', -180.0, 180.0, 0.5),
SDO_DIM_ELEMENT('LAT', -90.0, 90.0, 0.5)
),
8307
);
-- create spatial index
CREATE INDEX dept_spatial_idx
ON dept(geo_location)
INDEXTYPE IS mdsys.spatial_index;

FIND DEPARTMENTS WITHIN 500 KM FROM WASHINGTON DC
( [ -77.0364, 38.8951 ])
db.dept.find(
{
location : {
$near : {
$geometry : {
type : "Point" ,
coordinates : [ -77.0364, 38.8951 ]
},
$maxDistance : 500000
}
}
}
)
with d as
( SELECT loc
, SDO_GEOM.SDO_DISTANCE
( SDO_GEOMETRY(2001, 8307
, SDO_POINT_TYPE ( -77.0364, 38.8951,NULL)
, NULL, NULL
)
, geo_location
, 0.005
, 'unit=KM'
) distance
from dept
)
select d.*
from d
where d.distance < 500

ALL DEPARTMENTS, THE DISTANCE FOR EACH DEPARTMENT IN KILOMETER
FROM WASHINGTON DC, ORDERED BY THAT DISTANCE
db.dept.aggregate([
{ "$geoNear": {
"near": {
"type": "Point",
"coordinates": [ -77.0364, 38.8951 ]
},
"spherical": true,
"distanceField": "distanceFromTarget",
"distanceMultiplier": 0.001 // from meter to km
}}
, {$sort : {"distanceFromTarget":1}}
, {$project: {
_id: 0,
dname: 1,
loc: 1,
"distance from Washington DC":
{ $trunc : "$distanceFromTarget"},
}
}
])
with d as
( SELECT loc
, dname
, SDO_GEOM.SDO_DISTANCE
( SDO_GEOMETRY(2001, 8307
, SDO_POINT_TYPE ( -77.0364, 38.8951,NULL)
, NULL, NULL
)
, geo_location
, 0.005
, 'unit=KM'
) distance
from dept
)
select d.dname
, d.loc
, d.distance “distance from Washington DC”
from d
order
by d.distance

ADD BIOGRAPHIES TO EMPLOYEES (PREPARING FOR TEXT INDEX AND
SEARCH) AND CREATE TEXT INDEX
db.emp.findAndModify({
query: { ENAME: "KING" },
update: { $set: { "bio" : "Gerald Ford was born ...." }
},
upsert: true
})
query: { ENAME: "BLAKE" },
update: { $set: { "bio" : "Jamaican sprinter Yohan Blake
..." }
},
upsert: true
})
query: { ENAME: "FORD" },
update: { $set: { "bio" : "Harrison Ford is one of
...Han Solo." }
},
upsert: true
})
-- create text index, allowing use of text search
db.emp.createIndex(
{ ENAME:'text',
JOB:'text',
BIO:'text',
}
,{ weights: { ENAME:10, JOB:5, bio:1}
, name: 'employee_text_index'
}
)
update emp
set bio = q'[Gerald Ford was born ... in 2006.]'
where ename = 'KING‘
update emp
set bio = q'[Jamaican sprinter Yohan Blake holds
...]'
where ename = 'BLAKE'
-- create a multi column text index
exec ctx_ddl.create_preference
( 'my_mcds', 'multi_column_datastore' )
exec ctx_ddl.set_attribute
( 'my_mcds', 'columns', 'bio, ename, job' )
-- to support stemming
exec ctxsys.ctx_ddl.create_preference
('my_lexer','BASIC_LEXER');
exec ctxsys.ctx_ddl.set_attribute
('my_lexer','index_stems','1');
exec ctxsys.ctx_ddl.create_preference
('my_wordlist','BASIC_WORDLIST');
exec ctxsys.ctx_ddl.set_attribute
('my_wordlist','stemmer','ENGLISH');
create index emp_txt_idx on emp( ename )
indextype is ctxsys.context
parameters( 'datastore my_mcds WORDLIST my_wordlist
LEXER my_lexer' )

WHICH EMPLOYEES ARE FOUND WHEN LOOKING FOR SOMEONE TO LEAD?
db.emp.find(
{$text: {$search: 'lead'}}
,{ENAME:1}
)
-- leveraging the multicolumn text index
-- on ename, bio and job
SELECT ename
, SCORE(1)
FROM emp
WHERE CONTAINS(ename, 'lead', 1) > 0

TEXT SEARCH INCLUDING SCORING - APPLYING WEIGHT AND DERIVING
APPLICABILITY
db.emp.aggregate(
[{ $match: { $text: { $search: 'managing' } } }
,{ $project: {
_id:0,
ENAME: 1,
score: { $meta: 'textScore' } }
}
,{ $sort: {score:-1} }
]
)
-- leveraging stemming and the multicolumn text index
-- on ename, bio and job
SELECT ename
, SCORE(1) score
FROM emp
WHERE CONTAINS(ename, '$manage', 1) > 0
order
By score desc

Comparing 30 MongoDB operations with Oracle SQL statements

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to Comparing 30 MongoDB operations with Oracle SQL statements (20)

More from Lucas Jellema (20)

Recently uploaded (20)

Comparing 30 MongoDB operations with Oracle SQL statements