Oleg's questions

MySQL 表mytable有一列json_col数据以 JSON 格式存储，如下所示：

{
    "items": [
        {
            "name":"foo",
            "timestamp":"1612872027"
        },
        {
            "name":"bar",
            "timestamp":"1612872027"
        }
    ]
}

我正在尝试获取其元素foo的时间戳大于某个数字（例如零）的所有行：

select * from mytable 
  where json_contains(json_extract(json_col, '$.items'), "'foo'", '$[0].name')
  and cast(json_extract(json_col, '$.items[0].timestamp') as bigint) > 0

这里有2个问题：

1. foo可能不一定是第一个元素，不清楚如何搜索所有元素，而不仅仅是第一个（$[*]不起作用）
2. 不投入timestamp-bigint如示例中那样不起作用

mysql版本5.7.25

UPD

https://www.db-fiddle.com/f/nyTstzKyvBUzPw1GsWCygD/0

我希望选择前 2 行，因为它们包含一个元素foo并且它的值timestamp大于 0。
第三行不会被选择，因为它的foo值timestamp不大于 0。
第四个将不会被选中，因为它不包含foo.

假设我们有一个非常简单的表，其中包含两个整数列：

create table test (first int, second int);

我使用以下查询一次将数据插入其中：

insert into test (first, second) values (1,2), (2,3), (4,5); 

在这种情况下，在我从 type 的变量构建(1,2), (2,3), (4,5)之后带有数据的查询部分。因此，当一个空的进入并发生错误时，这种情况是可能的，因为请求将如下所示：valuesListList

insert into test (first, second) values ;

如何重写此查询，或者替换什么默认值，以便可以正确解释和执行查询而不会出错，但实际上不会插入任何内容。就像是：

insert into test (first, second) select 1,2, where false;

只需针对我的多次插入情况调整此查询。

假设我们有一个包含列的表：id, name, optional。在这种情况下，最后一列可能不存在。如果它不存在，那么您需要替换一些默认值。

像这样的东西：

select id, name, coalesce(optional, 'some default value') from my_table;

现在我收到该列optional不存在的错误。

是否可以在环境中组织类似的东西PostgreSQL？

有一种类型：

create type public.my_custom_type as
(
    some_field int,
    some_another_field text
);

不是在最后添加一个新字段，而是在这两个字段之间添加一个新字段有什么技巧吗？
就像是：

alter type public.my_custom_type add attribute new_field int after some_field;

word 上有一个语法错误after，显然只适用于枚举。如果after一切正常，但新字段会添加到末尾。

删除和重新创建是有问题的，因为基地的地板将在级联中从我身上删除。

有一个由一些实体组成的表，它们相互嵌套，一个实体从同一个表parent_id指向另一个实体：id

 entity
╔════╦═════════╦═══════════╗
║ id ║ name    ║ parent_id ║
╠════╬═════════╬═══════════╣
║ 0  ║ "Root"  ║ 0         ║ 
║ 1  ║ "One"   ║ 0         ║
║ 2  ║ "Two"   ║ 1         ║
║ 3  ║ "Three" ║ 4         ║
║ 4  ║ "Four"  ║ 3         ║
╚════╩═════════╩═══════════╝

这些实体可以通过 rest 进行编辑（或创建）。一般来说，查询很简单，归结为以下几点：

insert into entity (name, parent_id) values (${name}, ${parentId});
或
update entity set (name = ${name}, parent_id = ${parentId}) where id = ${id};

因为parentId你可以替换任何数字。那么像上面的例子一样，纯理论的情况是可能的：第三个实体指的是第四个，第四个指的是第三个。因此，我们得到了循环嵌套，并且不再可能从这些实体构建有效的树。

我认为parent_id添加实体时可以检查循环依赖关系，但我不知道如何使用Postgres. 有没有人已经为自己解决了这个问题？

来自@vp_arth 评论的UPD想法：

在另一个父项下添加或“移动”后，您可以获取该实体的所有父项的树：

  with recursive r as(
      select *
      from entity
      where id = $id
    union
       select et.*
       from entity as et
       join r
         on et.parent_id = r.id
   )
  select * from r

并在那里寻找给定的实体where id = ${entityId}。

问题在于，在这种形式中，如果存在循环嵌套，则此查询将“挂起”。（这是普遍预期的）

我设计了一个可以包含无效元素的反应流。按照设计，流应该简单地跳过它们。为此，我使用Observable.empty. 例如：

  Observable.fromIterable(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9))
    .flatMap(i =>
      if (i % 2 == 0) {   // Bad i
        Observable.empty
      } else
        Observable.pure(i)
    )
    .foreachL(i => print(s"Good i: $i"))   /*Output: Good i: 1
                                                     Good i: 3
                                                     Good i: 5
                                                     Good i: 7
                                                     Good i: 9*/

这段代码基本上可以工作，尽管它按顺序处理元素。但我积极使用长 IO 操作，所以我决定从.mapParallelUnordered. 结果是这样的：

  Observable.fromIterable(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9))
    .mapParallelOrdered(3)(i =>
      if (i % 2 == 0) {
        Task.raiseError(new Exception(s"Bad i: $i"))
      } else
        Task.pure(i)
    )
    .foreachL(i => print(s"Good i: $i"))    /*Output: Good i: 1*/

问题是它会Task.raiseError...杀死整个线程，导致它在第一个偶数处停止。

在第二种情况下，您如何跳过Observable.empty无效元素的反应流程 (a la ) 的所有其他步骤，同时保持流程的执行？

假设有JSON一个复杂的结构：

{
  "a":"aa",
  "b":"bb",
  "c":[
    "aaa",
    "bbb"
  ],
  "d":{
    "e":"ee",
    "f":"ff"
  }
}

我想把所有字符串都大写。我在文档中找到了这个：

root.each.string.modify(_.toUpperCase)

正如预期的那样，只有根字段将被应用。

是否有可能以某种方式递归遍历整个 json 并应用我的函数？
结构json是事先不知道的。

这是一个关于scastie的例子

假设有一个表，其中包含一些在执行期间可以接收不同状态的进程：

 process               process_status
╔════╦════════╗       ╔════╦════════════╦════════════╦═════════╗
║ id ║ name   ║       ║ id ║ process_id ║ date       ║ status  ║
╠════╬════════╣       ╠════╬════════════╬════════════╬═════════╣
║ 1  ║  One   ║       ║ 1  ║ 1          ║ 2018-10-10 ║ Start   ║ 
║ 2  ║  Two   ║       ║ 2  ║ 1          ║ 2018-10-15 ║ Running ║
║ 3  ║  Three ║       ║ 3  ║ 1          ║ 2018-10-30 ║ Running ║
╚════╩════════╝       ║ 4  ║ 1          ║ 2018-11-01 ║ Running ║
                      ║ 5  ║ 1          ║ 2018-11-02 ║ Error   ║
                      ║ 6  ║ 1          ║ 2018-11-03 ║ Error   ║
                      ╚════╩════════════╩════════════╩═════════╝

如您所见，状态可以不同，每个状态可以接收多次。

我只对状态Running和Error. 现在我得到这样的记录：

select p.id, p.name from process p 
  join process_status ps
  on p.id = ps.process_id
  where ps.status = 'Running' or ps.status = 'Error';

结果，返回 5 行。三个带有 status Running，两个带有 status Error。

是否有可能以某种方式只返回 2 行？最先收到的Running（如果有的话）和/或最先收到的Error（如果有的话）？

理想情况下，返回Running在某个日期或之后首次收到的所有进程，例如2018-10-16 OR第一个Error在其他日期或之前收到的进程，例如2018-10-17？

可能吗？

因此，理想情况下，我只需要满足此条件的进程：

╔══════╦════════╗ 
║ p.id ║ p.name ║   
╠══════╬════════╣
║ 1    ║  One   ║ 
╚══════╩════════╝ 

UPD
让我稍微解释一下我的任务：

现在在系统中，所有进程及其所有状态都被从数据库中提取出来Running并且Error（大约与我给出的查询），并且已经从代码的一侧搜索了那些已经收到第一个状态Running或Error不迟于的进程某个日期。

事实。每天启动大约 8-1 万个（有时更多）进程，它们的数量已经达到数千万。每个进程还接收大约 10,000 个状态。

目前没有性能问题，但我正在运行影响此代码的任务。在我看来，从数据库到应用程序有太多不必要的数据。因此，既然我无论如何都在重构这部分代码，我想让它更优化，即不是在代码中减去数百万个进程并从中选择几十个必要的进程，而是立即只返回这10个必要的进程，并且只与他们合作。

有一个简单的build.sbt：

name := "CryptoToolsTest"

version := "0.1"

scalaVersion := "2.12.6"

javaOptions += s"-Djava.library.path=${baseDirectory.value / "bicrypt"}"

如果我正确理解了所有内容，那么这样一个最小的构建就足够了。但是，我写了这段代码：

object Main extends App {
  System.getProperty("java.library.path")
    .split(";")
    .map(println)
} 

我在那里看到了任何东西，但没有看到文件夹bicrypt。
还有什么需要添加到构建中？

我在以下内容build.sbt中添加了一个自定义存储库：

name := "CryptoToolsTest"

version := "0.1"

scalaVersion := "2.12.6"

resolvers += "3rd party" at "http://some.custom.uri.ru:8081/nexus/content/repositories/thirdparty/"

libraryDependencies ++= Seq(
  "ru.group" % "artifact_1" % "1.0",
  "org.group" % "artifact_2" % "1.0"
)

使用此配置，自定义存储库3rd party可用于搜索所有依赖项。
如何使其SBT在自定义存储库中查找，例如，artifact_2仅查找依赖项？

我正在尝试使用Gatling.

在模拟的主体中，我在系统中创建了一个带有休息请求的实体。本系统假设在创建实体时，id不应该由数据库发出，而是在请求中传入（因此假设id是事先知道的）。

面临这样一个问题：我随机生成
同一个。id由于模拟几乎同时运行多个查询，因此每 15 次左右运行的随机种子是相同的。因此，它们生成相同id的 ，每 15 个请求中有 14 个下降。

这是我的模拟代码：

class BasicSimulation extends Simulation {
  val httpConf = http
    .baseUrls("http://localhost:8080", "http://localhost:8081")

  val scn = scenario("BasicSimulation")
    .exec(
      http("Create entity")
        .post("/v1/api/entity")
        .header(HttpHeaderNames.ContentType, HttpHeaderValues.ApplicationJson)
       .body{
          val id = new Random().nextInt(Int.MaxValue) + 1  // Вот в этой строке генерится одно и то же
                                                           // число для одновременных запусков 
          StringBody(s"""{"id":$id, "name":"${UUID.randomUUID()}"}""")
       }
       .check(jsonPath("$..id").ofType[Int].saveAs("eid"))
    )

  setUp(scn.inject(heavisideUsers(4).during(1 second)).protocols(httpConf))
}

如何在模拟中制作“真实”随机？
或者，我怎样才能Gatling在请求之间强制暂停，以便每个人都获得不同的随机种子？
或任何其他有助于解决此问题的方法。

让我把我的问题翻译成一个经典的例子。假设有一张买家和采购表。很明显，每个客户可以进行 0 到 N 次购买：

    customer              order
   ╔════╦════════╗       ╔════╦═════════════╦════════════╗
   ║ id ║ name   ║       ║ id ║ customer_id ║date        ║
   ╠════╬════════╣       ╠════╬═════════════╬════════════╣
   ║ 1  ║  One   ║       ║ 1  ║  1          ║ 2018-10-10 ║       
   ║ 2  ║  Two   ║       ║ 2  ║  1          ║ 2018-10-15 ║
   ║ 3  ║  Three ║       ║ 3  ║  2          ║ 2018-10-30 ║
   ╚════╩════════╝       ╚════╩═════════════╩════════════╝

我需要将购买加入客户

select * 
  from customer c 
  left join order o 
  on c.id = o.custoner_id;

因此，在与买家所在的行中，要么有最后一次购买，要么根本没有购买。

因此，每位客户只能在决赛桌中出现一次。

有一张桌子tbl：

id | f_key | alive
-------------------
   |       |

还有更多的领域，但它们并不重要。

我想知道我是否有多个当前“活动”记录 (alive = true) 引用相同的“f_key”。

我自己能做什么：
我可以写一个简单的查询

select * from tbl where alive = true order by f_key;

并亲眼看到：如果连续两行或多行具有相同的f_key，那么这就是我要找的。

但我想以某种方式自动化这项工作。我知道这个问题很简单，你只需要在 condition 的某个地方添加一个聚合函数count()，它的值不止一个，但我很困惑在哪里。

我有一个无法连接到互联网的工作电路。在其中，我尝试使用 UI 思想来浏览数据库。连接设置屏幕：

当然，通过单击Download missing driver files，不会下载驱动程序。

曾几何时，我已经解决了这个问题。我记得可以手动下载驱动程序（我有机会从外部将文件带入电路中），并将其放在某个地方，但这次我找不到驱动程序的确切位置.

假设我们有一个简单的表：

id | some_fk | value
--------------------
1  | 1       | 3

我像这样将数据插入其中：

insert into table (some_fk, value) values (1, 3) returning id

some_fk如果这样的记录已经存在这样的值，DBMS 如何防止插入记录？

也就是说，在这种情况下，例如values (1, 4)，您可以插入，但values (1, 3)不能，因为已经存在具有此类值的记录。

我无法更改数据库的结构。只对表读写数据。

有没有办法在守卫内等待未来的执行？
不在case块内或块外Try：

import scala.util.Try
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

object Main extends App {
  val f = Future {
    Thread.sleep(999999)
    true
  }

  Try (1) match {
    case x if f => println("Waited for future")  // Here
    case _ => println(":(")
  }
}

感谢您的关注

假设我们有 2 个相关实体，让它成为一些group：

group: {
  id,
  name
}

还有一些user：

user: {
  id,
  name,
  age,
  groups
}

在过去的良好休息中，如果我想将 Vasya 添加到 Admin 组和其他组，我会发送一些请求：

PUT /user/1

{"id":1,"name":"Вася","age":30,"groups":[1,2]}

或者我会添加一个特殊的端点来将用户绑定到组。就像是：

POST /user/1/groups

[1,2]

问题： 就 而言，相同的动作是什么样的GraphQL？

同事们，我不知道如何从diode. 这是一段代码App Circuit：

val handler = new ActionHandler(myZoomedState) {
    override def handle = {
      case action => effectOnly(Effect(someFuture map {_ =>
        someAction  //Этот экшен не отрабатывает
        someOtherAction  //Этот отрабатывает
      }))

      case someAction => ???
      case someOtherAction => ???
    }
}

怎么把它们锁起来？类似于我们对回调所做的事情：
someCallback >> someOtherCallback

对许多人来说一个非常简单的问题：

有一个表category（id, name）
和一些实体的相关表entity（id, category_id, name）

有必要提取所有类别和每个类别中的实体数量。发表者

select * from category left join entity on category.id = entity.id

然后是死胡同。

让我给你一个非常简单的例子。有一条线str，比方说：

user=123456(somelogin)

您需要获取用户 ID 和他的登录名。现在我这样做了：

String id = str.replaceAll(".*user=(\\d+).*", "$1");
String name = str.replaceAll(".*user=\\d+\\((.*)\\).*", "$1");

有没有一种通用的方法可以通过组合 2 个正则表达式一步完成？

也许它不会像在支持元组或解构的语言中那样完美，但我对使用正则表达式.*user=(\\d+)\\((.*)\\).*并在输出中获取字符串数组的选项感到满意，其中第一个元素是第一个组，第二个是第二个。