全部问题(coding)

这是该问题的一个演示。

当我使用下面的 SQL 来获取特定数据时，我什么也没得到。

select * from tmp where ord ='904000009‬‬‬' or trim(ord) ='904000009‬‬‬';

但是当我使用 select * 和搜索功能时，我可以看到数据。这是一个文本列，我尝试使用 trim 删除空格，但仍然不起作用。

select * from tmp;

我尝试了如下所示的许多变体，但都没有效果。

选择 ord，* 从 tmp 中排除 ord，其中 ord ='904000009' 或 trim(ord) ='904000009' ；从 tmp 中选择 *，其中'00'||ord ='00904000009' ；

根据要求，这里是仅显示好行而不显示坏行的 SQL。

with t as (select  '4000009616‬‬‬' c, 'good' indicator union all select  '4000009616' as c , 'bad' indicator)
select * from t
where c='4000009616‬‬‬';

最小示例

df <- data.frame(x = c(10, NA, 30, 40, 50),                  
                  y = c(10, 20, NA, 40, 50))

df <- df |>
       na.omit() |>
       `colnames<-`(c("You", "Me")) 
>df
      You Me
    1  10 10
    4  40 40
    5  50 50

我想将过滤后的数据框的行重新排序，使其从 1 到行数。我知道可以这样写

> rownames(df) <- NULL
> df
  You Me
1  10 10
2  40 40
3  50 50

如何使用基本 R 管道实现与 colnames 相同的目的？

提前致谢

托马斯·菲利普斯

在本地测试时，所有页面都能正常渲染。但加载到 GitHub Pages 时，只有首页会使用主题渲染。点击链接打开子页面时，子页面的主题不会加载。

但是，如果我在新浏览器选项卡中使用其完整链接直接加载子页面，则会应用主题。

以下是信息：主页：https://deepworkmonk.com
子页面：https://deepworkmonk.com/blogs/books-i-recommend/

代码：https://github.com/meenaren/DeepWorkMonkWebsite/blob/main/_config.yml

我该如何解决这个问题？

简而言之，我正在尝试在 Oracle Netsuite 中复制 Excel 的 TEXTJOIN 函数。

更详细：我在 Oracle Netsuite 中有一个字段需要执行以下操作：

第 1 部分：如果满足某些条件，则为第 1 部分写入一些文本，否则保留空白第 2 部分：如果满足某些条件，则为第 2 部分写入一些文本，否则保留空白第 3 部分：... 一直到第 n 部分

无法保证这些部分都存在。一旦所有部分都存在（或不存在），我需要用分隔符（“|”）将它们连接起来。所以它可能只是“第 1 部分”，也可能是“第 1 部分|第 2 部分”，或者“第 2 部分|第 4 部分”，或者“第 1 部分|第 2 部分|第 3 部分|....|第 n 部分”。

如何使用 Oracle Netsuite 的函数执行此操作？目前我最多只需要处理 2 个，但我可能需要回过头来将其写到 11 个甚至更多。

有什么想法吗？

目前我有以下部分：

第 1 部分：

CASE WHEN {shiptype} IS NULL THEN '' ELSE 'SHIP='||{shiptype} END

第 2 部分：

CASE WHEN {packagetype} IS NULL THEN '' ELSE 'PACKAGEID='||{packagetype} END

因此针对这两个人的计划是这样的：

CASE WHEN {shiptype} IS NULL THEN '' ELSE 'SHIP='||{shiptype} END
CASE WHEN {shiptype} IS NULL OR {packagetype} IS NULL THEN '' ELSE '|' END
CASE WHEN {packagetype} IS NULL THEN '' ELSE 'PACKAGEID='||{packagetype} END

这只对这两个有用，但我不确定这对第三个、第四个等是否有效。有什么想法吗？

例如：

function makeFunc(a,b,c,d,e) {
    return () => {
        if (a) { /* do something expensive not referencing b,c,d,e */ }
        if (b) { /* do something expensive not referencing a,c,d,e */ }
        if (c) { /* do something expensive not referencing a,b,d,e */ }
        if (d) { /* do something expensive not referencing a,b,c,e */ }
        if (e) { /* do something expensive not referencing a,b,c,d */ }
    }
}

const func = makeFunc(true, false, false, false, false)
for ( let i=0; i < 100_000; i++) func()

我希望，在这个例子中，V8 能够优化if (x)闭包上的测试，只发出

/* do something expensive not referencing b,c,d,e */

if (a)执行100,000次之后。

我正在尝试逐个遍历 Pandas DataFrame 的列值，以检测符合正则表达式模式的子字符串，并在其出现的任何位置替换它。DataFrame 目标列中的字符串值具有以下变体：

1. ‘函数（某物）……’
2. ‘func（某物，某物）……’

我尝试使用第二种变体来定位值，并用同一行中另一列的值替换逗号分隔的子字符串。

我的示例代码如下：

import re
for i, x in enumerate(df['col1']):
  df.loc[i,'col2'] = re.sub(r'^(func\().+,.+(\).*)', r'\1%s\2'%(x), df.loc[i,'col2'])

*当我将模式中的替换为 时，终端上获得了成功的输出+：

>>> val = 'func(y,z) and func2(a,b)'
>>> val
'func(y,z) and func2(a,b)'
>>> pattern1 = r'^(func\().+,.+(\).*)'
>>> replacement = r'\1%s\2'%('x')
>>> val2 = re.sub(pattern1, replacement, val) 
>>> val2
'func(x)'
>>> pattern2 = r'^(func\().+,.+(\).+)'
>>> val2 = re.sub(pattern2, replacement, val) 
>>> val2
'func(x) and func2(a,b)'
>>> val3 = 'func(y) and func2(a,b)'
>>> val4 = re.sub(pattern2, replacement, val3) 
>>> val4
'func(y) and func2(a, b)'

我认为.*inpattern1应该能够容纳最后捕获的括号后的 0 个或更多任意字符实例\)，但至少使用.+inpattern2是可行的。

问题是，当我尝试在 VSCode 上使用 Python 复制 DataFrame 的列值时，我没有得到想要的输出。我想我的正则表达式模式捕获了字符串中我不想要的部分，所以得到了混合的结果。

我遗漏了什么吗pattern2？

更新： 这是我在 VSCode 中使用的示例代码，其中结果很有希望，但是当字符串添加更多条件时，模式就不再成立。

df = pd.DataFrame({'col1':['func(a,b) and func(c,d)','func(a) and func(c)','func(b) and func(c,d)','func(a,b,c) and func(d,e,f)'],
                   'col2':['e','b','a','g']})
df
>>>
    col1    col2
0   func(a,b) and func(c,d) e
1   func(a) and func(c) b
2   func(b) and func(c,d)   a
3   func(a,b,c) and func(d,e,f) g

import re
df['col3'] = ''
for i,x in enumerate(df['col2']):
    pattern = r'^(func\().+,.+(\).+)'
    replacement = fr'\1{x}\2'
    df.loc[i,'col3'] = re.sub(pattern,replacement,df.loc[i,'col1'])
    if df.loc[i,'col3'] != df.loc[i,'col1']:
        print(df.loc[i,'col1'],'--->',df.loc[i,'col3'])
>>>
func(a,b) and func(c,d) ---> func(e) and func(c,d)
func(a,b,c) and func(d,e,f) ---> func(g) and func(d,e,f)

以上是我期望看到的，但在下面的尝试中，您可以看到附加func()条件被删除：

df = pd.DataFrame({'col1':['func(a,b) and func(c,d) and func2(z)','func(a) and func(c) and func2(z)','func(b) and func(c,d) and func2(z)','func(a,b,c) and func(d,e,f) and func2(z)'],
                   'col2':['e','b','a','g']})
df
>>>
    col1    col2
0   func(a,b) and func(c,d) and func2(z)    e
1   func(a) and func(c) and func2(z)    b
2   func(b) and func(c,d) and func2(z)  a
3   func(a,b,c) and func(d,e,f) and func2(z)    g

import re
df['col3'] = ''
for i,x in enumerate(df['col2']):
    pattern = r'^(func\().+(?:,.+)+(\).+)'
    replacement = fr'\1{x}\2'
    df.loc[i,'col3'] = re.sub(pattern,replacement,df.loc[i,'col1'])
    if df.loc[i,'col3'] != df.loc[i,'col1']:
        print(df.loc[i,'col1'],'--->',df.loc[i,'col3'])

>>>
func(a,b) and func(c,d) and func2(z) ---> func(e) and func2(z)
func(b) and func(c,d) and func2(z) ---> func(a) and func2(z)
func(a,b,c) and func(d,e,f) and func2(z) ---> func(g) and func2(z)

该模式似乎忽略了中间的func()表达。

此页面列出了 ActiveMQ Artemis JMS Client 的“中央”版本（从 1.0 到 2.40），并且此页面链接到每个版本的发行说明。

mvnrepository.com 页面还列出了“JBoss 版本”：

JBoss 各个版本的发行说明在哪里？WildFly/JBoss 的哪个版本与哪个“中央”版本相关？

我制作了一些模板，旨在

• （1）测试数字是否可以相加而不溢出，
• （2）添加数字，如果溢出则失败。

test_sum里面的(1)static_assert编译通过了，所以我猜是的constexpr。
为了避免重复计算，我尝试将断言直接放在计算和的 (2) 函数中。然而，在下面的所有版本中，无论条件如何，断言总是失败。有什么办法可以解决这个问题吗？

#include <limits>
#include <stdexcept>
#include <type_traits>

template<typename T>
constexpr bool add(T& a, T b)
{
    static_assert(std::is_integral<T>::value, "Only integral types are supported");

    if ((b > 0) && (a > std::numeric_limits<T>::max() - b))
        return false;
    if ((b < 0) && (a < std::numeric_limits<T>::min() - b))
        return false;

    a += b;
    return true;
}

//

template<typename T>
constexpr bool sum_impl(T& result)
{
    return true;
}

template<typename T, typename... Rest>
constexpr bool sum_impl(T& result, T value, Rest... rest)
{
    if (!add(result, value))
        return false;

    return sum_impl(result, rest...);
}

//

template<typename T, typename... Rest>
constexpr bool test_sum(T value, Rest... rest) // (1)
{
    return sum_impl(value, rest...);
}

template<typename T, typename... Rest>
T sum(T value, Rest... rest) // (2) regular
{
    if (!sum_impl(value, rest...))
        throw std::overflow_error("Overflow in checked::sum");

    return value;
}

template<typename T, typename... Rest>
constexpr T sum_cexpr(T value, Rest... rest) // (2) constexpr
{
//  if (!sum_impl(value, rest...))
//      static_assert(false, "Overflow"); // fail

//  static_assert(sum_impl(value, rest...), "Overflow"); // fail

//  if (!sum_impl(value, rest...))
//      delegated_assert<false>(); //  fail

    return value;
}

template<bool B>
constexpr void delegated_assert()
{
    if constexpr (!B)
        static_assert(B);
}

//////

int main()
{
    static_assert(test_sum(1, 2)); // (1) works

    constexpr int a = sum_cexpr(10, 20, 30); // fails to compile
    
    return 0;
}

我正在思考这个问题的答案：如何测试泛型变量是否属于 AnyObject 类型

该解决方案似乎不再起作用。我有以下代码：

public struct ObjectHashable<T>: Hashable {
  
  public let object: T
  
  public init(object: T) {
    
    let t1 = type(of: object)
    let b1 = t1 is AnyClass
    print(t1) // Plugin
    print(b1) // false
    
    let t2 = T.self
    let b2 = t2 is AnyClass
    print(t2) // Plugin 
    print(b2) // false
    
    let t3 = Mirror(reflecting: object).subjectType 
    let b3 = t3 is AnyClass 
    print(t3) // P
    print(b3) // true 

    self.object = object
    
  }
  
  public static func ==(lhs: Self, rhs: Self) -> Bool {
    return true
  }
  
  public func hash(into hasher: inout Hasher) {
  }
}

protocol Plugin: AnyObject {}
class P: Plugin {}

typealias PluginHashable = ObjectHashable<Plugin>

PluginHashable(object: P())

这是一个令人惊讶的行为。

1.

let t1 = type(of: object)

type(of:)应该返回动态类型，即P，而不是Plugin。但我打印出了“插件”。

2.

let b1 = t1 is AnyClass

因为 t1 是引用类型，所以它不应该是真的吗？（基于此处的答案：如何测试泛型变量是否属于 AnyObject 类型）

3.

let t2 = T.self

打印出来Plugin，这是有道理的，因为我输入Plugin了<>

4.

let b2 = t2 is AnyClass

这是错误的，但我认为出于同样的原因，它应该是正确的

5.

    let t3 = Mirror(reflecting: object).subjectType // P

打印出来P，这是有道理的

6.

    let b3 = t3 is AnyClass // true

确实如此，这很有道理。但为什么它与其他两种情况不同呢？

我正在使用 Firestore。它需要安全规则。

以下是我针对集合组运行的实际查询：

const db = getFirestore(app);
const MainCollection = collectionGroup(db, "list");

const searchQuery = query(
  MainCollection,
  where("destination", "==", itinerary.destination),    
);

收集路径为 /maincollection/{userId}/list/{documents=**}。

CoPilot 建议的 Firebase 规则：

match /maincollection/{userId} {
  allow read: if request.auth != null;
  match /list/{document=**} {
      allow read: if request.auth != null;
    }
}

match /maincollection/{doc}/list/{itin} {
  allow read: if request.auth != null;
}

    match /maincollection/{doc}/list/{document=**} {
  allow read: if request.auth != null;
}

    match /maincollection/{document=**} {
  allow read, write: if request.auth != null;
}

所有这些都给我以下错误：

搜索行程时出错：FirebaseError：缺少或权限不足。