标签: batching

问题很简单:我需要为NancyFX添加批量请求支持.

最近我在github上发现了关于Nancy批处理支持的问题.问题是很久以前创建的,但仍然没有任何可行的解决方案.这个问题 - 我唯一提到的Nancy批处理我发现了!

使用来自该gist和pull请求的代码,我们可以解析批处理请求到部件,并创建Nancy Request对象.我们甚至可以将它们发送给NancyEngine.

var contentType = new ContentType(Request.Headers.ContentType);
var multipartRequest = new HttpMultipart(Request.Body, contentType.Boundary);

foreach (var boundry in multipartRequest.GetBoundaries())
{
    var subRequest = boundry.Value.ReadAsRequest(); // our extension

    nancyEngine.HandleRequest(subRequest,
        context =>
        {
            // success
        },
        exception =>
        {
            // error
        });
}

但是我从多个Nancy响应中创建批量响应时遇到了麻烦.我需要像MultipartContentASP WebApi 这样的类,但是对于Nancy来说.

有谁知道任何工作南希配料解决方案？或者可以帮助创建多个Nancy响应的批量响应？

我在尝试在AspNETCore Web应用程序上配置OData的批处理时遇到了一些问题.我到处搜索(差不多),找不到合适的答案.我不确定当前仍然是beta的AspNetCore.Odata版本7.0.0是否支持批处理.

就我而言,现在配置批处理似乎是不可能的,因为该MapODataServiceRoute方法(来自AspNetCore的说明)似乎没有ODataBatchHandler像.NET常见的Odata那样接收任何方法.

app.UseMvc(routes =>
    {
        routes.Count().Filter().OrderBy().Expand().MaxTop(null);
        routes.MapODataServiceRoute("odata", "odata", builder.GetEdmModel()); //Doesn't receive any ODataBatchHandler
        routes.EnableDependencyInjection();
});

如果有人遇到Odata核心的这个批处理问题,一些建议会非常有用.谢谢!

我已经使用TPL数据流实现了producer..consumer模式。用例是代码从Kafka总线读取消息。为了提高效率，我们需要在访问数据库时分批处理消息。

TPL数据流中是否有方法可以保留消息并在达到大小或持续时间阈值时触发？

例如，当前实现将消息从队列中拉出后就将其发布。

    postedSuccessfully = targetBuffer.Post(msg.Value);

在 Kafka 中，有没有办法在消费了几个相关消息后生成消息？（无需在应用程序代码中手动控制它...）

用例是选择一个大文件，将其分成几个块，为主题中的每个块发布一条消息，一旦所有这些消息都被消耗掉，就会产生另一条消息，通知另一个主题的结果。

我们可以使用数据库或 REDIS 来控制状态，但我想知道是否有任何仅利用 Kafka 生态系统的更高级别的方法。

对SQL Server 2008使用NHibernate 2.1.2.4000.目标表没有触发器或无关索引.它很简单:

create table LogEntries (
    Id INT IDENTITY NOT NULL,
   HostName NVARCHAR(32) not null,
   UserName NVARCHAR(64) not null,
   LogName NVARCHAR(512) not null,
   Timestamp DATETIME not null,
   Level INT not null,
   Thread NVARCHAR(64) not null,
   Message NVARCHAR(MAX) not null,
   primary key (Id)
)

我的实体映射是:

<class name="LogEntry" table="LogEntries">
    <id name="Id" unsaved-value="0">
        <generator class="native"/>
    </id>
    <property name="HostName" length="32" not-null="true"/>
    <property name="UserName" length="64" not-null="true"/>
    <property name="LogName" length="512" not-null="true"/>
    <property name="Timestamp" type="utcdatetime" not-null="true"/>
    <property name="Level" not-null="true"/>
    <property name="Thread" length="64" not-null="true"/>
    <property name="Message"> …

我一直在编写一个基于MSBuild的构建系统,并且到项目结束时我需要通过批处理三个变量来实际运行一个msbuild文件88次:

Configuration = Debug; 测试版; 发布; 评估
平台= x86; x64
语言= CN; CS; DE; EN; ES; FR; 它; J.P; KO; PL; TW

我想构建:
"Debug x86 CN","Debug x86 CS",..."Debug x86 TW"
"Debug x64 CN",...

当然,我可以定义其中的88个:

<ItemGroup>
  <ToBuild Include="Debug_x86_CN">
    <Configuration>Debug</Configuration>
    <Platform>x86</Platform>
    <Language>EN</Language>
  </ToBuild>
<ItemGroup>

然后基于元数据批处理.但真是拖累!我可以在代码中创建88个排列,因此添加语言就像向ItemGroup添加三个字符一样简单:

<ItemGroup>
  <AllConfigurations Include="Beta; Release; Evaluation;"/>
  <AllPlatforms Include="x86; x64" />
  <AllLanguages Include="CN; CS; DE; EN; ES; FR; IT; JP; KO; PL; TW" />
</ItemGroup>

我正在学习使用 java 的 hibernate 5.2.10。我从一些在线教程开始，但面临以下问题。

在使用batching的时候，我看过的所有教程都是先hibernate.jdbc.batch_size在配置文件中设置的。之后的代码类似于：

Session session = SessionFactory.openSession();
Transaction tx = session.beginTransaction();
for ( int i=0; i<1000000; i++ ) 
{
    Student student = new Student(.....);
    session.save(employee);
    if( i % 50 == 0 ) // Same as the JDBC batch size
    { 
        //flush a batch of inserts and release memory:
        session.flush();
        session.clear();
    }
}
tx.commit();
session.close();

为什么要我做flush()和clear()手动？这不是应该由hibernate自动完成的，因为我已经hibernate.jdbc.batch_size在配置文件中设置了吗？

对我来说，似乎我正在手动批处理我的操作，那么为什么我必须设置hibernate.jdbc.batch_sizethen的值呢？

为了不耗尽内存，在 Keras 中执行以下操作是否合乎逻辑？

for path in ['xaa', 'xab', 'xac', 'xad']:
    x_train, y_train = prepare_data(path)
    model.fit(x_train, y_train, batch_size=50, epochs=20, shuffle=True)

model.save('model')

我在https://react-redux.js.org/api/batch上读到，可以使用batch“来确保在 React 之外调度的多个操作只会导致单个渲染更新”，就像这样（我在 React 事件中使用）处理程序即）：

...
const submitData = event => {
    // ... some code before
    batch(() => {
        dispatch(first())
        dispatch(second())
    })
}
...

但我的问题是如何正确batch操作，redux-saga以便在从 saga 分派多个操作时，结果是一次重新渲染而不是多次重新渲染？我试图将多个put放在all数组中，但不确定它实际上是批处理put：

yield all([
    put(addFirst({first: 1})),
    put(addAnother({second: 2)),
]);

上面的方法是因为我在https://github.com/manaflair/redux-batch上阅读了作者写的文档“自从这个包被写出来，redux-saga 改进并使用了 all([ put(...), put(...) ]) 似乎将这两个操作正确地批处理为单个订阅事件，在这种情况下使 redux-batch 变得多余。 ”，但在https://github.com/manaflair/redux-batch/issues/ 21另一个人写道，批处理由React unstable_batchedUpdates API. 仍然redux-toolkit（我使用）具有用一个例子redux-batch为store enhancer …

我正在忙于编写一个迁移，该迁移将使我们能够将yamler从Syck迁移到Psych，并最终将项目升级到ruby2。尽管如此，该迁移将占用大量资源，因此我将需要使用分块。

我编写了以下方法来确认我计划使用的迁移结果能够产生预期的结果，并且可以在不停机的情况下完成。为了避免Active Record自动执行序列化，我需要使用ActiveRecord::Base.connection.execute

我描述转换的方法如下

 def show_summary(table, column_name)
  a = ActiveRecord::Base.connection.execute <<-SQL
   SELECT id, #{column_name} FROM #{table}
  SQL
  all_rows = a.to_a; ""
  problem_rows = all_rows.select do |row|
    original_string = Syck.dump(Syck.load(row[1]))
    orginal_object = Syck.load(original_string)

    new_string = Psych.dump(orginal_object)
    new_object = Syck.load(new_string)

    Syck.dump(new_object) != original_string rescue true
  end

problem_rows.map do |row|
  old_string = Syck.dump(Syck.load(row[1]))
  new_string = Psych.dump(Syck.load(old_string)) rescue "Parse failure"
  roundtrip_string = begin
    Syck.dump(Syck.load(new_string))
  rescue => e
    e.message
  end

  new_row = {}
  new_row[:id] = row[0]
  new_row[:original_encoding] = old_string
  new_row[:new_encoding] = roundtrip_string
  new_row
  end …