Question

在我的sequelize网络应用上使用nodejs，我想使用分页（按日期）查询帖子。阅读sequelize docs，他们可以使用offset和limit。

由于我想显示从新到旧的帖子，我需要考虑它们的创建日期。例如，如果我将第一个查询限制为10页，并且在执行第二个查询之前创建了一个新帖子，则下一个偏移量为10的查询将导致上一个查询的重复发布。

我应该如何实施分页以便支持新条目？

Answer 1

如果你想要一个稳定的分页，不要对行偏移进行分页，因为它是不稳定的，因为你提到的原因。

您应该针对随时间稳定的值进行分页，并使用where子句来过滤结果。最好的情况是如果你有一个自动递增的id，但是发布日期也可能是合理的。

类似的东西：

Post.findAll({ 
where: { createdDate: { $lt: previousDate }, 
limit: 10
})

您需要跟踪此ofc的previousDate。这种方法也有一些注意事项，您可能需要将其与客户端重复数据删除相结合。

这是一篇博客文章，可能包含您需要的所有答案： Pagination: You're (Probably) Doing It Wrong

Answer 2

最简单的方法是使用Sequelize＆＃39; findAndCountAll

Post.findAndCountAll({
    where: {...},
    order: [...],
    limit: 5,
    offset: 0,
}).then(function (result) {
    res.render(...);
});

此处，结果包含您的查询结果，并计为result.row和result.count。然后，您可以增加偏移量并将其用于分页。

Greensock SVG Morph Plugin

Answer 3

您可以简单地做到这一点

let limit = 10
let offset = 0 + (req.body.page - 1) * limit
Posts.findAndCountAll({
        offset: offset,
        limit: limit,
        order: [
            ['date', 'ASC']
        ]
    }).then(async result => {
        return res.status(200).json({
            status: true,
            message: res.__('success'),
            innerData: result
        })
    })
    .catch(err => {
        return validator.InvalidResponse(res, `${err}`)
    })

Answer 4

带有findAndCountAll ，这里的计数对于分页很有用，我们可以根据需要限制该总数，也可以使用async和await来限制

let resAccidents =等待ModalName.findAndCountAll（{其中：{createdByID：employeeID}，偏移量：0，限制：10}）;

这将根据where条件及其第1 10条记录返回总记录数，然后增加offset的值以获取更多记录

Answer 5

尝试一下：

const paginate = (query, { page, pageSize }) => {
  const offset = page * pageSize;
  const limit = pageSize;

  return {
    ...query,
    offset,
    limit,
  };
};


model.findAll(
  paginate(
    {
      where: {}, // conditions
    },
    { page, pageSize },
  ),
);

为了避免样板代码

Answer 6

改为尝试

db.findAll（{ 偏移量：page_no，//您的页码限制：25，//您的限制

Answer 7

private void Form1_Load(object sender, EventArgs e)
     {

         con = new SqlConnection();
         con.ConnectionString= (@"Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=H:\New\RemDaBase.mdf;Integrated Security=True;Connect Timeout=30");
         con.Open();
         adapt = new SqlDataAdapter("SELECT * FROM  TB1", con);
         DataTable dt = new DataTable();
         BindingSource bs = new BindingSource();
         bs.DataSource = dt;
         adapt.Fill(dt);
         dataGridView1.DataSource = dt;
     }

private void button1_Click(object sender, EventArgs e)
{
    try
    {
        cmdbl = new SqlCommandBuilder(adapt);
        adapt.Update(dt);
        MessageBox.Show("Updated Successfully");
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.ToString());

    }
}

var defered = Q.defer();
const offset = queryString.offset * queryString.limit;
const limit = queryString.limit;
var queryWhere = { class_id: { $ne: null }, section_id: { $ne: null } };
var searchClass = {};
var searchSection = {};
if (queryString) {
    if (queryString.class && queryString.class !== "") {
       searchClass = { class_id: { $eq: queryString.class } };
    } else if (queryString.class && queryString.class === "") {
       searchClass = { class_id: { $ne: null } };
    }

if (queryString.section && queryString.section !== "") {
      searchSection = { section_id: { $eq: queryString.section } };
} else if (queryString.section && queryString.section === "") {
      searchSection = { section_id: { $ne: null } };
}
}

queryWhere = {
    $and: [[searchClass], [searchSection]]
};
const schoolDB = require("../../db/models/tenant")(schema);
const Student = schoolDB.model("Student");
Student.findAll({
   attributes: [
  "id",
  "first_name",
  "last_name",
  "profile_image_url",
  "roll_number",
  "emergency_contact_number"
],
offset: offset,
limit: limit,
where: queryWhere,
order: [["roll_number", "ASC"]]
})
.then(result => {
  defered.resolve(result);
})
.catch(err => {
  defered.reject(err);
});

Recommended using Sequelize's own operators

Answer 8

这个解决了我的问题。

export const paginate = (query, schema) => {
  let page = query.page ? query.page - 1 : 0;
  page = page < 0 ? 0 : page;
  let limit = parseInt(query.limit || 10);
  limit = limit < 0 ? 10 : limit;
  const offset = page * limit;
  const where = {};
  delete query.page;
  delete query.limit;
  Object.keys(schema).forEach((key) => {
    schema[key] && query[key] ? (where[key] = query[key]) : null;
  });
  return {
    where: where,
    offset,
    limit,
  };
};

@Get()
findAll(@Query() query): unknown {
  return this.model.findAll(paginate(query, {xx:1}));
}

/model?xx=yy&page=1&limit=5

Sequelize分页

8 个答案: