We are generating SQL Query with sequelize. Below is the code sample. We already have tries all possible ways like nest: true, distinct: true, raw: true But none of the things work to generate the correct sql
Associations:
db.MeasurementVersions.belongsTo(db.Measurements, {
foreignKey: 'measurementId',
sourceKey: 'id',
as: 'measurementDetails',
});
db.MeasurementVersions.hasMany(db.MeasurementVersions, {
foreignKey: 'measurementId',
sourceKey: 'measurementId',
as: 'measurementVersionsGrouped',
});
db.Measurements.hasMany(db.TakeoffHasMeasurements, {
foreignKey: 'measurementId',
sourceKey: 'id',
});
db.TakeoffHasMeasurements.hasMany(db.TakeoffHasMeasurements, {
foreignKey: 'measurementId',
sourceKey: 'measurementId',
as: 'TakeoffHasMeasurementsMeasurementRightSelfJoin',
});
Sequelize Code
db.MeasurementVersions.findAll({
subQuery: true,
attributes: [[fn('MAX', col(`${db.MeasurementVersions.tableName}.modifiedDate`)), 'MaxTime']],
include: [
{
model: db.MeasurementVersions,
where: {
modifiedDate: { [Operator.eq]: col(`${db.MeasurementVersions.tableName}.MaxTime`) },
status: 'active',
},
as: 'measurementVersionsGrouped',
},
{
attributes: [['quantity', 'quantity'], 'estimateId', 'fileVersionId'],
model: db.Measurements,
as: 'measurementDetails',
required: true,
where: { estimateId },
include: [
{
model: db.TakeoffHasMeasurements,
subQuery: true,
attributes: [[fn('MAX', col(`${db.TakeoffHasMeasurements.tableName}.updatedDate`)), 'MaxTime5']],
include: [
{
model: db.TakeoffHasMeasurements,
as: 'TakeoffHasMeasurementsMeasurementRightSelfJoin',
where: {
updatedDate: { [Operator.eq]: col(`${db.TakeoffHasMeasurements.tableName}.MaxTime5`) },
status: 'active',
},
},
],
},
],
},
],
group: ['measurementId'],
});
The generated SQL query is as below:
SELECT *
FROM
(SELECT
`measurementVersions`.`id`,
MAX(`measurementVersions`.`modifiedDate`) AS `MaxTime`,
`measurementVersions`.`measurementId`,
`measurementDetails->takeoff_has_measurements`.`id` AS `measurementDetails.takeoff_has_measurements.id`,
MAX(`takeoff_has_measurements`.`updatedDate`) AS `measurementDetails.takeoff_has_measurements.MaxTime5`
FROM
`measurementVersions` AS `measurementVersions`
LEFT OUTER JOIN `takeoff_has_measurements` AS `measurementDetails->takeoff_has_measurements` ON `measurementDetails`.`id` = `measurementDetails->takeoff_has_measurements`.`measurementId`
WHERE
(SELECT
`measurementDetails`.`id`
FROM
`measurements` AS `measurementDetails`
LEFT OUTER JOIN (`takeoff_has_measurements` AS `takeoff_has_measurements`
INNER JOIN `takeoff_has_measurements` AS `takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin` ON `takeoff_has_measurements`.`measurementId` = `takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`measurementId`
AND `takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`updatedDate` = `takeoff_has_measurements`.`MaxTime5`
AND `takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`status` = 'active') ON `measurementDetails`.`id` = `takeoff_has_measurements`.`measurementId`
WHERE
(`measurementDetails`.`estimateId` = 'e861a343-ed44-4af5-b488-758c464f416b'
AND `measurementDetails`.`id` = `measurementVersions`.`measurementId`)
LIMIT 1) IS NOT NULL
GROUP BY `measurementId`) AS `measurementVersions`
INNER JOIN
`measurementVersions` AS `measurementVersionsGrouped` ON `measurementVersions`.`measurementId` = `measurementVersionsGrouped`.`measurementId`
AND `measurementVersionsGrouped`.`modifiedDate` = `measurementVersions`.`MaxTime`
AND `measurementVersionsGrouped`.`status` = 'active'
INNER JOIN
`measurements` AS `measurementDetails` ON `measurementVersions`.`measurementId` = `measurementDetails`.`id`
AND `measurementDetails`.`estimateId` = 'e861a343-ed44-4af5-b488-758c464f416b'
INNER JOIN
`takeoff_has_measurements` AS `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin` ON `measurementDetails.takeoff_has_measurements.measurementId` = `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`measurementId`
AND `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`updatedDate` = `takeoff_has_measurements`.`MaxTime5`
AND `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`status` = 'active'
But the expected SQL Query we need is as below(denoted with **):
SELECT *
FROM
(SELECT
`measurementVersions`.`id`,
MAX(`measurementVersions`.`modifiedDate`) AS `MaxTime`,
`measurementVersions`.`measurementId`
FROM
`measurementVersions` AS `measurementVersions`
GROUP BY `measurementId`) AS `measurementVersions`
INNER JOIN
`measurementVersions` AS `measurementVersionsGrouped` ON `measurementVersions`.`measurementId` = `measurementVersionsGrouped`.`measurementId`
AND `measurementVersionsGrouped`.`modifiedDate` = `measurementVersions`.`MaxTime`
AND `measurementVersionsGrouped`.`status` = 'active'
INNER JOIN
`measurements` AS `measurementDetails` ON `measurementVersions`.`measurementId` = `measurementDetails`.`id`
AND `measurementDetails`.`estimateId` = 'e861a343-ed44-4af5-b488-758c464f416b'
LEFT OUTER JOIN (`takeoff_has_measurements` AS `measurementDetails->takeoff_has_measurements`
INNER JOIN **( select MAX(`takeoff_has_measurements`.`updatedDate`) from `takeoff_has_measurements` AS `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`
ON `measurementDetails->takeoff_has_measurements`.`measurementId` = `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`measurementId`
AND `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`updatedDate` = `takeoff_has_measurements`.`MaxTime5`
AND `measurementDetails->takeoff_has_measurements->TakeoffHasMeasurementsMeasurementRightSelfJoin`.`status` = 'active')**)
ON `measurementDetails`.`id` = `measurementDetails->takeoff_has_measurements`.`measurementId`
It should generate the correct sql
Related
await a.findAll({
where: {status: 1},
include: [
{
model: b,
association: b.hasOne(a,{foreignKey:'a_id',as:"childData"}),
where: {
status: 1,
},
required: false,
},
],
});
I got this query using the above sequelize method.
select * from a inner join b on a.id=b.a_id where a.status=1, b.status=1
But I want a query like this. Both a subquery and the Join method must be used. So how can I do it?
(select * from a where status=1) X inner join (select * from b where status=1) Y ON X.id=Y.a_id
I have a query that I select some columns and I do left join. I'm using MariaDB at MySQL Workbench.
The Query that I trying to run
sequelize.query(`SELECT
distinct av.idAnnouncementVehicles as id,
av.price,
CONCAT("https://autoparanaiba.s3-sa-east-1.amazonaws.com/" , SUBSTRING_INDEX(ap.image, '.', 1) , '-355x180.' , SUBSTRING_INDEX(ap.image, '.', -1)) as image,
am.worked_hours,
am.year AS ano,
md.description AS modelo,
bn.description AS marca,
fu.description AS combustivel,
pw.description AS potência,
tc.description AS tração
FROM announcement_vehicles AS av
left join announcemment_photos AS ap on ap.annoucements_id = av.idAnnouncementVehicles
left join persons AS pe on pe.id = av.personId
left join agricultural_machine AS am on am.agricultural_machine_id = av.itemId
left join itens AS it on it.id = av.itemId
left join traction AS tc on tc.id = trac.traction_id
left join power AS pw on pw.id = trac.power_id
left join fuel AS fu on fu.id = trac.fuel_id
where it.type=${type} and (av.plans_id IS NOT NULL or pe.type = 'jud')
group by av.idAnnouncementVehicles order by av.plans_id, av.idAnnouncementVehicles desc limit 8`, { type: sequelize.QueryTypes.SELECT })
.then((result) => {
return res.json({ success: true, result: result })
}).catch((err) => {
return res.status(400).json(err)
})
This query is returning this error to me. But I have a similar query in the code that does not throw this error.
The error
{
"name": "SequelizeDatabaseError",
"parent": {
"code": "ER_BAD_FIELD_ERROR",
"errno": 1054,
"sqlState": "42S22",
"sqlMessage": "Unknown column 'md.description' in 'field list'",
The similar query that I have
sequelize.query(`SELECT
distinct av.idAnnouncementVehicles as id,
av.price,
CONCAT("https://autoparanaiba.s3-sa-east-1.amazonaws.com/" , SUBSTRING_INDEX(ap.image, '.', 1) , '-355x180.' , SUBSTRING_INDEX(ap.image, '.', -1)) as image,
ve.mileage,
fi.marca,
fi.name,
fi.ano,
fi.ano_modelo as modelo,
fu.description as combustivel
FROM announcement_vehicles as av
left join announcemment_photos as ap on ap.annoucements_id = av.idAnnouncementVehicles
left join persons as pe on pe.id = av.personId
left join vehicles as ve on ve.item_id = av.itemId
left join itens as it on it.id = av.itemId
left join fipe as fi on fi.id = ve.fipe_id
left join fuel as fu on fu.id = ve.fuel_id
left join color as co on co.id = ve.color_id
where it.type=${type} and (av.plans_id IS NOT NULL or pe.type = 'jud')
group by av.idAnnouncementVehicles order by av.plans_id, av.idAnnouncementVehicles desc limit 8`, { type: sequelize.QueryTypes.SELECT })
.then((result) => {
return res.json({ success: true, result: result })
}).catch((err) => {
return res.status(400).json(err)
})
I resolved the problem with this query
sequelize.query(`SELECT
distinct av.idAnnouncementVehicles as id,
av.price,
CONCAT("https://autoparanaiba.s3-sa-east-1.amazonaws.com/" , SUBSTRING_INDEX(ap.image, '.', 1) , '-355x180.' , SUBSTRING_INDEX(ap.image, '.', -1)) as image,
am.worked_hours,
am.year AS ano,
md.description AS modelo,
bn.description AS marca,
fu.description AS combustivel,
pw.power AS potência,
tc.description AS tração
FROM announcement_vehicles AS av
left join announcemment_photos AS ap on ap.annoucements_id = av.idAnnouncementVehicles
left join persons AS pe on pe.id = av.personId
left join agricultural_machine AS am on am.agricultural_machine_id = av.itemId
left join model_agricultural_machine as md on md.id = am.model_agricultural_machine_id
left join brand_agricultural_machine as bn on bn.id = am.brand_agricultural_machine_id
left join tractor as trc on trc.tractor_id = am.agricultural_machine_id
left join power as pw on pw.id = trc.power_id
left join itens AS it on it.id = av.itemId
left join traction AS tc on tc.id = trc.traction_id
left join fuel AS fu on fu.id = trc.fuel_id
where it.type=${type} and (av.plans_id IS NOT NULL or pe.type = 'jud')
group by av.idAnnouncementVehicles order by av.plans_id, av.idAnnouncementVehicles desc limit 8`, { type: sequelize.QueryTypes.SELECT })
.then((result) => {
return res.json({ success: true, result: result })
}).catch((err) => {
return res.status(400).json(err)
})
This Query returns 'Unknown position.name in field list'.
dummy_schema.positions
SELECT JSON_OBJECT(
'id', userData.id,
'email', userData.email,
'first_name', userData.first_name,
'last_name', userData.last_name,
'mood', userData.mood,
'uuid', userData.uuid,
'role', userData.role,
'rawRole', IF(userData.role = 'cls_administrator', 'Administrator', IF(userData.role = 'cls_moderator', 'Moderator', IF(userData.role = 'cls_member', 'Member', ''))),
'position', userData.position,
'rawPosition', position.position,
'lastSeen', userData.lastSeen,
'added', userData.added) AS profile
FROM dummy_schema.users AS userData
LEFT JOIN dummy_schema.positions AS position ON userData.position = position.id
WHERE id = 1;
MySQL V6.3 Workbench
You can try to give dummy_schema.positions table other aliases name instead of position because your alias is position but there is a column has same name position that will let DB engine confuse.
SELECT JSON_OBJECT
(
'id', userData.id,
'email', userData.email,
'first_name', userData.first_name,
'last_name', userData.last_name,
'mood', userData.mood,
'uuid', userData.uuid,
'role', userData.role,
'rawRole', IF(userData.role = 'cls_administrator', 'Administrator', IF(userData.role = 'cls_moderator', 'Moderator', IF(userData.role = 'cls_member', 'Member', ''))),
'position', userData.position,
'rawPosition', p.position,
'lastSeen', userData.lastSeen,
'added', userData.added
) AS profile
FROM dummy_schema.users AS userData
LEFT JOIN dummy_schema.positions AS p ON userData.position = p.id
WHERE id = 1;
I am struggling on how to generate the correct query with Doctrine 1.2 to retrieve my products where the associated simple_products have a total stock greater than 1 (at least one of them has a stock of 1 or more)
My schema.yml:
Product:
columns:
id:
Simple_product:
columns:
id:
quantity: { type: integer }
product_id: { type: integer(11), notnull: true }
relations:
product_id: { class: Product, local: product_id, foreign: id, foreignAlias: Simple_products }
Example query I tried:
$qProducts = Doctrine_Query::create()
->select('p.*, SUM(s.quantity)')
->from('Product p')
->innerJoin('p.Simple_products s')
->where('p.category_id = ?', $_SESSION['eshop'],
->andWhere('p.brand = ?', $_SESSION['eshop'],
->andWhere('p.is_active = 1')
->having('SUM(s.quantity) > 0');
This query doesn't return expected results, it returns an empty collection even though I know the database contains products with associated simple products with stock.
What am I doing wrong?
EDIT:
$qProducts->getSqlQuery() returns:
SELECT p.id AS p__id, p.sku AS p__sku, p.name AS p__name, p.gender AS p__gender, p.description AS p__description, p.custom_price AS p__custom_price, p.base_price AS p__base_price, p.sales_price AS p__sales_price, p.eshop_price AS p__eshop_price, p.brand AS p__brand, p.product_url AS p__product_url, p.image_url AS p__image_url, p.is_active AS p__is_active, p.category_id AS p__category_id, SUM(s.quantity) AS s__0 FROM product p INNER JOIN simple_product s ON p.id = s.product_id WHERE (p.category_id = ? AND p.brand = ? AND p.is_active = 1) HAVING SUM(s.quantity) > 0
The DQL query I was looking for:
$qNbProducts = Doctrine_Query::create()
->select('p.id')
->addSelect('SUM(s.quantity) as sum_stock')
->from('Product p')
->innerJoin('p.Category c')
->leftJoin('p.Simple_products s')
->where('c.root_id = ?', $categoryId)
->andWhere('p.brand = ?', $_SESSION['eshop'])
->andWhere('p.is_active = 1')
->groupBy('p.id')
->having('sum_stock > 0');
I have the following query that works, but after talking to the client I realized I need left joins to get the desired results and I don't know how to do it.
This is my query:
$query = $this->AssetStatusAudits->find('all', [
'contain' => [
'AssetStatus',
'Users',
'Assets' => function ($q) {
return $q->contain([
'Employees',
'Sites'
]);
}
],
'conditions' => [
'AssetStatusAudits.created >' => $from,
'AssetStatusAudits.created <' => $to
]
]);
$query->select([
'createdDate' => 'date(AssetStatusAudits.created)',
'assetStatus' => 'AssetStatus.desc_en',
'firstName' => 'Users.first_name',
'lastName' => 'Users.last_name',
'count' => $query->func()
->count('*')
])
->group('date(AssetStatusAudits.created)', 'assetStatus.desc_en', 'users.last_name')
->order('Users.last_name', 'Users.created');
The above query generates this in cake:
SELECT date(AssetStatusAudits.created) AS `createdDate`,
AssetStatus.desc_en AS `assetStatus`,
Users.first_name AS `firstName`,
Users.last_name AS `lastName`,
(COUNT(*)) AS `count`
FROM asset_status_audits AssetStatusAudits
INNER JOIN asset_status AssetStatus ON AssetStatus.id = (AssetStatusAudits.asset_status_id)
INNER JOIN users Users ON Users.id = (AssetStatusAudits.user_id)
INNER JOIN assets Assets ON Assets.id = (AssetStatusAudits.asset_id)
LEFT JOIN employees Employees ON Employees.id = (Assets.employee_id)
INNER JOIN sites Sites ON Sites.id = (Assets.site_id)
WHERE (AssetStatusAudits.created > date('2016-01-13') AND AssetStatusAudits.created < date('2016-05-03'))
GROUP BY date(AssetStatusAudits.created)
ORDER BY Users.last_name
But this is the query that I need to add to cakePHP and I don't know how to do it:
SELECT
date(asset_tracking.asset_status_audits.created) as 'Date',
asset_tracking.asset_status.desc_en as 'Status',
asset_tracking.users.first_name as 'First Name' ,
asset_tracking.users.last_name as 'Last Name',
count(*)
FROM asset_tracking.asset_status_audits
LEFT OUTER JOIN asset_tracking.assets ON asset_tracking.asset_status_audits.asset_id = asset_tracking.assets.id
LEFT OUTER JOIN asset_tracking.asset_status ON asset_tracking.asset_status_audits.asset_status_id = asset_tracking.asset_status.id
LEFT OUTER JOIN asset_tracking.users ON asset_tracking.asset_status_audits.user_id = asset_tracking.users.id
LEFT OUTER JOIN asset_tracking.employees ON asset_tracking.assets.employee_id = asset_tracking.employees.id
LEFT OUTER JOIN asset_tracking.sites ON asset_tracking.assets.site_id = asset_tracking.sites.id
WHERE asset_tracking.asset_status_audits.created between date('2016-01-13') and date('2016-05-19')
group by
date(asset_tracking.asset_status_audits.created) ,
asset_tracking.asset_status.desc_en,
asset_tracking.users.last_name
ORDER BY asset_tracking.users.last_name, asset_tracking.users.created;