标签: operator

当有人这样做时，我正在我们的一台测试服务器上运行跟踪：

我可以在跟踪中捕获的查询之一是：

declare @UserOption int
select @UserOption=convert(int, c.value) from sys.configurations c where c.name='user options'

SELECT
CAST(@UserOption & 1 AS bit) AS [DisableDefaultConstraintCheck],
CAST(@UserOption & 2 AS bit) AS [ImplicitTransactions],
CAST(@UserOption & 4 AS bit) AS [CursorCloseOnCommit],
CAST(@UserOption & 8 AS bit) AS [AnsiWarnings],
CAST(@UserOption & 16 AS bit) AS [AnsiPadding],
CAST(@UserOption & 32 AS bit) AS [AnsiNulls],
CAST(@UserOption & 64 AS bit) AS [AbortOnArithmeticErrors],
CAST(@UserOption & 128 AS bit) AS [IgnoreArithmeticErrors],
CAST(@UserOption & 256 AS bit) AS [QuotedIdentifier],
CAST(@UserOption & …

'+' 运算符在以下语句中的表现如何？

select + 'taco';  --Result is 'taco'

它是与第一个字符串空白（'' + 'taco'）进行字符串连接，还是其他意思？

我试图在查询中使用感叹号作为非运算符

SELECT !0, !!0, !!!0, !1, !!1, !!!1, !2, !!2, !!!2;

| !0 | !!0 | !!!0 | !1 | !!1 | !!!1 | !2 | !!2 | !!!2 |
|----|-----|------|----|-----|------|----|-----|------|
| 1  | 1   | 0    | 0  | 0   | 1    | 0  | 0   | 1    |

结果令人惊讶，但如果我添加括号或空格，它会像我想象的那样工作：

SELECT !0, !(!0), !(!(!0)), !1, !(!1), !(!(!1)), !2, !(!2), !(!(!2));
SELECT !0, ! !0, ! ! !0, !1, ! !1, ! ! !1, !2, ! !2, ! ! !2; …

你能解释一下这两个运算符之间的区别吗？

sID != smth 而不是 sID = smth。

乍一看，它们似乎完全相同。但它们给出了不同的结果。

我们有一个简单的语法，允许我们查看单个标量的数组，

SELECT 'foo' = ANY(ARRAY['foo', 'bar', 'baz']);

我们可以用同样的方法来匹配 LIKE

SELECT 'foobar' LIKE ANY(ARRAY['foo%', 'bar%', 'baz%'];

我的问题是，如果你想做另一个。

SELECT ANY(ARRAY['foobar', 'barbar', 'bazbar']) LIKE 'foo%' 
ERROR:  syntax error at or near "ANY"
LINE 1: SELECT ANY(ARRAY['foobar', 'barbar', 'bazbar']) LIKE 'foo%';

我知道语法不起作用，但我希望它起作用。

# SELECT ARRAY['foobar', 'barbar', 'bazbar'] LIKE 'foo%';
ERROR:  operator does not exist: text[] ~~ unknown
LINE 1: SELECT ARRAY['foobar', 'barbar', 'bazbar'] LIKE 'foo%';
HINT:  No operator matches the given name and argument type(s). You might need to add explicit type casts.

我想过滤一个数组以查看元素是否存在。这可能不使用 …

虽然我可以

SELECT elem[1], elem[2]
FROM   ( VALUES ('1,2'::TEXT) ) AS q(arr),
       LATERAL CAST(String_To_Array(q.arr, ',') AS INT[]) AS elem
;

使用显式调用CAST，我不能

SELECT elem[1], elem[2]
FROM   ( VALUES ('1,2'::TEXT) ) AS q(arr),
       LATERAL String_To_Array(q.arr, ',')::INT[] AS elem
;

使用隐式调用::运算符：

错误：“::”处或附近的语法错误

另一个CAST需要显式的位置：

CREATE INDEX ON ... ( CAST(<straw> AS <gold>) );

我怀疑是否存在句法原因，例如使用额外的括号 - 这在这里是不正确的。

此时是否只需要显式函数调用作为低级实现的一部分？或者它是否遵循任何语言规则？

我想创建一个扩展事件会话，并使用like_i_sql_unicode_string运算符过滤短语[demo]，并使用方括号。我从以下开始：

CREATE EVENT SESSION [demo] ON SERVER 
ADD EVENT sqlserver.sql_batch_completed(
    WHERE ([sqlserver].[like_i_sql_unicode_string]([sqlserver].[sql_text],N'%[demo]%'))
)
ADD TARGET package0.ring_buffer
alter event session [demo] on server state=start

但这会解释[demo]为类似正则表达式的语法上的字符组。所以如果我运行这个：

-- m

它将在扩展事件中捕获。

我得到的最接近的是稍后过滤它，使用[sqlserver].[like_i_sql_unicode_string]([sqlserver].[sql_text],N'%demo%')过滤器然后：

SELECT
n.ev.value('@timestamp','datetimeoffset') as [timestamp],
n.ev.value('data[@name="batch_text"][1]','varchar(max)')  as [batch_text]
FROM sys.dm_xe_session_targets xet
INNER JOIN sys.dm_xe_sessions xe ON xe.[address] = xet.event_session_address
cross apply (select CONVERT(XML, target_data) as xData ) as x
cross apply x.xData.nodes(N'RingBufferTarget/event') AS n(ev)
WHERE xe.name = N'demo' AND xet.target_name = N'ring_buffer'
and n.ev.value('data[@name="batch_text"][1]','varchar(max)') like …

如果我在同一列上创建两个（或多个）不同类型的索引，PostgreSQL 的行为如何？

就我而言，我想将 B 树索引与tsvector列上的 GIN 进行比较。我知道 GIN 专门用于tsvector. 奇怪的是，如果我创建 B 树索引，PostgreSQL 不会抱怨，但我看到查询计划器不使用它。我还可以创建 GIN 索引（不删除 B 树索引），现在规划器使用新创建的索引。该列现在有两个索引，但只使用了其中一个。

即使存在两个以上的索引，用于选择索引类型的标准是什么？为什么 PostgreSQL 不告诉我 a 上的 B 树索引tsvector是无用的，并且不会永远不会被计划者使用？

更新
GIN 索引仅用于某些检查条件，例如my_tsvector IS NOT NULL但（显然）不适用于my_tsvector @@ '...'::tsquery.

当我尝试使用一个 JSON 元素访问时，->>'elementName'我得到了一个text类型。

SELECT pg_typeof(x1->>'a'), jsonb_typeof(x2)
FROM ( VALUES
  ('{"a":5}'::jsonb, '5'::jsonb)
) AS t(x1,x2);

 pg_typeof | jsonb_typeof 
-----------+--------------
 text      | number
(1 row)

但是，jsonb表示它将数字映射到数字类型......

将文本 JSON 输入转换为 jsonb 时，RFC 7159 描述的原始类型有效地映射到本机 PostgreSQL 类型，如表 8-23 所示。

这是从文档中复制的表格，

表 8-23。JSON 原始类型和对应的 PostgreSQL 类型

JSON primitive type     PostgreSQL type  Notes
string                  text             \u0000 is disallowed, as are non-ASCII Unicode escapes if database encoding is not UTF8
number                  numeric          NaN and infinity values are disallowed
boolean                 boolean …

在$all操作者选择的文件，其中一个字段的值是包含所有指定元素的数组。

在我的情况下，我需要相反的内容：选择文档的运算符，其中字段的值是一个数组，其元素都包含在指定的数组中。

例如，考虑以下集合：

{"name": 1, "vals": ["A", "B"]}
{"name": 2, "vals": ["D", "C"]}
{"name": 3, "vals": ["A", "D"]}

我想选择其vals字段包含值的所有文档["A", "B", "D"]；也就是说，文档 1 和 3（不是 2，因为指定的数组中不包含“C”）。

我不能使用{vals: {$all: ["A", "B", "D"]}}，也不能{vals: ["A", "B", "D"]}因为这两个操作选择其vals字段包含所有指定值的文档，这不是我想要的。

我需要的可能吗？