cwielenb/CNCF-Dataset huggingface dataset:
Project: ShardingSphere (App Definition and Development / Database)
File: create-readwrite-splitting-rule.en.md

+++ title = "CREATE READWRITE_SPLITTING RULE" weight = 1 +++ The `CREATE READWRITE_SPLITTING RULE` syntax is used to create a read/write splitting rule. {{< tabs >}} {{% tab name="Grammar" %}} ```sql CreateReadwriteSplittingRule ::= 'CREATE' 'READWRITE_SPLITTING' 'RULE' ifNotExists? readwriteSplittingDefinition (',' readwriteSplittingDefinition)* ifNotExists ::= 'IF' 'NOT' 'EXISTS' readwriteSplittingDefinition ::= ruleName '(' dataSourceDefinition (',' transactionalReadQueryStrategyDefinition)? (',' loadBalancerDefinition)? ')' dataSourceDefinition ::= 'WRITESTORAGEUNIT' '=' writeStorageUnitName ',' 'READSTORAGEUNITS' '(' storageUnitName (',' storageUnitName)* ')' transactionalReadQueryStrategyDefinition ::= 'TRANSACTIONALREADQUERY_STRATEGY' '=' transactionalReadQueryStrategyType loadBalancerDefinition ::= 'TYPE' '(' 'NAME' '=' algorithmType (',' propertiesDefinition)? ')' ruleName ::= identifier writeStorageUnitName ::= identifier storageUnitName ::= identifier transactionalReadQueryStrategyType ::= string algorithmType ::= string propertiesDefinition ::= 'PROPERTIES' '(' key '=' value (',' key '=' value)* ')' key ::= string value ::= literal ``` {{% /tab %}} {{% tab name="Railroad diagram" %}} <iframe frameborder="0" name="diagram" id="diagram" width="100%" height="100%"></iframe> {{% /tab %}} {{< /tabs >}} `transactionalReadQueryStrategyType` specifies the routing strategy for read query within a transaction, please refer to ; `algorithmType` specifies the load balancing algorithm type, please refer to ; Duplicate `ruleName` will not be created; `ifNotExists` clause used to avoid the `Duplicate readwrite_splitting rule` error. ```sql CREATE READWRITESPLITTING RULE msgroup_0 ( WRITESTORAGEUNIT=write_ds, READSTORAGEUNITS(readds0,readds1), TYPE(NAME="random") ); ``` read/write splitting rule ```sql CREATE READWRITESPLITTING RULE IF NOT EXISTS msgroup_0 ( WRITESTORAGEUNIT=write_ds, READSTORAGEUNITS(readds0,readds1), TYPE(NAME="random") ); ``` `CREATE`, `READWRITESPLITTING`, `RULE`, `WRITESTORAGEUNIT`, `READSTORAGE_UNITS` , `TYPE`, `NAME`, `PROPERTIES`, `TRUE`, `FALSE`
Project: Beam (App Definition and Development / Streaming & Messaging)
File: 24_io_json.md

Prompt: Is JSON supported in Apache Beam? Response: is a data format for storing and exchanging data. Apache Beam supports reading data from and writing data to JSON files using the `ReadFromJson` and `WriteToJson` transforms within the `TextIO` module. For more information, see the TextIO connector documentation in the following languages: To get started with JSON and Apache Beam, refer to the . Here is an example of Apache Beam pipeline code for reading data from a JSON file: ```python class JsonOptions(PipelineOptions): @classmethod def addargparse_args(cls, parser): parser.add_argument( '--file_path', default="gs://your-bucket/your-file.json", help='Json file path' ) options = JsonOptions() with beam.Pipeline(options=options) as p: output = (p | "Read from Json file" >> ReadFromJson( path=options.file_path, lines=False ) | "Log Data" >> Map(logging.info)) ```
Project: StarRocks (App Definition and Development / Database)
File: like.md

displayed_sidebar: "English" Checks whether a given expression fuzzy matches the specified pattern. If yes, 1 is returned. Otherwise, 0 is returned. NULL is returned if any of the input parameter is NULL. LIKE is usually used together with characters such as the percent sign (%) and underscore (). `%` matches 0, 1, or more characters. `` matches any single character. ```Haskell BOOLEAN like(VARCHAR expr, VARCHAR pattern); ``` `expr`: the string expression. The supported data type is VARCHAR. `pattern`: the pattern to match. The supported data type is VARCHAR. Returns a BOOLEAN value. ```Plain Text mysql> select like("star","star"); +-+ | like('star', 'star') | +-+ | 1 | +-+ mysql> select like("starrocks","star%"); +-+ | like('star', 'star') | +-+ | 1 | +-+ mysql> select like("starrocks","star_"); +-+ | like('starrocks', 'star_') | +-+ | 0 | +-+ ```
Project: EMQ Technologies (App Definition and Development / Streaming & Messaging)
File: feat-12016.en.md

Enhanced license key management. EMQX can now load the license key from a specified file. This is enabled by setting the `license.key` configuration to a file path, which should be prefixed with `"file://"`. Also added the ability to revert to the default trial license by setting `license.key = default`. This option simplifies the process of returning to the trial license if needed.
Project: StarRocks (App Definition and Development / Database)
File: current_version.md

displayed_sidebar: "English" Returns the current version of StarRocks. Two syntaxes are provided for compatibility with different clients. ```Haskell current_version(); @@version_comment; ``` None Returns a value of the VARCHAR type. ```Plain Text mysql> select current_version(); +-+ | current_version() | +-+ | 2.1.2 0782ad7 | +-+ 1 row in set (0.00 sec) mysql> select @@version_comment; +-+ | @@version_comment | +-+ | StarRocks version 2.1.2 | +-+ 1 row in set (0.01 sec) ```
Project: Apache Storm (App Definition and Development / Streaming & Messaging)
File: Maven.md

title: Maven layout: documentation documentation: true To develop topologies, you'll need the Storm jars on your classpath. You should either include the unpacked jars in the classpath for your project or use Maven to include Storm as a development dependency. Storm is hosted on Maven Central. To include Storm in your project as a development dependency, add the following to your pom.xml: ```xml <dependency> <groupId>org.apache.storm</groupId> <artifactId>storm-client</artifactId> <version>{{page.version}}</version> <scope>provided</scope> </dependency> ``` of a pom.xml for a Storm project. Please refer to for more details.
Project: Meshery (Provisioning / Automation & Configuration)
File: envoy.md

layout: integration title: Envoy subtitle: Collaborative and visual infrastructure as code for Envoy image: /assets/img/integrations/envoy/icons/color/envoy-color.svg permalink: extensibility/integrations/envoy docURL: https://docs.meshery.io/extensibility/integrations/envoy description: integrations-category: Orchestration & Management integrations-subcategory: Service Proxy registrant: Artifact Hub components: featureList: [ "Drag-n-drop cloud native infrastructure designer to configure, model, and deploy your workloads.", "Invite anyone to review and make changes to your private designs.", "Ongoing synchronization of Kubernetes configuration and changes across any number of clusters." ] howItWorks: "Collaborative Infrastructure as Code" howItWorksDetails: "Collaboratively manage infrastructure with your coworkers synchronously sharing the same designs." language: en list: include type: extensibility category: integrations
Project: StarRocks (App Definition and Development / Database)
File: pipeAdvantages.md

Pipe is ideal for continuous data loading and large-scale data loading: Large-scale data loading in micro-batches helps reduce the cost of retries caused by data errors. With the help of Pipe, StarRocks enables the efficient loading of a large number of data files with a significant data volume in total. Pipe automatically splits the files based on their number or size, breaking down the load job into smaller, sequential tasks. This approach ensures that errors in one file do not impact the entire load job. The load status of each file is recorded by Pipe, allowing you to easily identify and fix files that contain errors. By minimizing the need for retries due to data errors, this approach helps to reduce costs. Continuous data loading helps reduce manpower. Pipe helps you write new or updated data files to a specific location and continuously load the new data from these files into StarRocks. After you create a Pipe job with `"AUTO_INGEST" = "TRUE"` specified, it will constantly monitor changes to the data files stored in the specified path and automatically load new or updated data from the data files into the destination StarRocks table. Additionally, Pipe performs file uniqueness checks to help prevent duplicate data loading.During the loading process, Pipe checks the uniqueness of each data file based on the file name and digest. If a file with a specific file name and digest has already been processed by a Pipe job, the Pipe job will skip all subsequent files with the same file name and digest. Note that {props.menu} as file digest. The load status of each data file is recorded and saved to the `informationschema.pipefiles` view. After a Pipe job associated with the view is deleted, the records about the files loaded in that job will also be deleted.
Project: BigchainDB (App Definition and Development / Database)
File: node-assumptions.md

<! Copyright 2020 Interplanetary Database Association e.V., BigchainDB and IPDB software contributors. SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0) Code is Apache-2.0 and docs are CC-BY-4.0 > Be sure you know the key BigchainDB terminology: Note that there are a few kinds of nodes: A dev/test node is a node created by a developer working on BigchainDB Server, e.g. for testing new or changed code. A dev/test node is typically run on the developer's local machine. A bare-bones node is a node deployed in the cloud, either as part of a testing network or as a starting point before upgrading the node to be production-ready. A production node is a node that is part of a consortium's BigchainDB network. A production node has the most components and requirements. We make some assumptions about production nodes: Each production node is set up and managed by an experienced professional system administrator or a team of them. Each production node in a network is managed by a different person or team.
Project: ClickHouse (App Definition and Development / Database)
File: clickhouse-disks.md

slug: /en/operations/utilities/clickhouse-disks sidebar_position: 59 sidebar_label: clickhouse-disks A utility providing filesystem-like operations for ClickHouse disks. Program-wide options: `--config-file, -C` -- path to ClickHouse config, defaults to `/etc/clickhouse-server/config.xml`. `--save-logs` -- Log progress of invoked commands to `/var/log/clickhouse-server/clickhouse-disks.log`. `--log-level` -- What of events to log, defaults to `none`. `--disk` -- what disk to use for `mkdir, move, read, write, remove` commands. Defaults to `default`. `copy [--disk-from d1] [--disk-to d2] <FROMPATH> <TOPATH>`. Recursively copy data from `FROM_PATH` at disk `d1` (defaults to `disk` value if not provided) to `TO_PATH` at disk `d2` (defaults to `disk` value if not provided). `move <FROMPATH> <TOPATH>`. Move file or directory from `FROMPATH` to `TOPATH`. `remove <PATH>`. Remove `PATH` recursively. `link <FROMPATH> <TOPATH>`. Create a hardlink from `FROMPATH` to `TOPATH`. `list [--recursive] <PATH>...` List files at `PATH`s. Non-recursive by default. `list-disks`. List disks names. `mkdir [--recursive] <PATH>`. Create a directory. Non-recursive by default. `read: <FROMPATH> [<TOPATH>]` Read a file from `FROMPATH` to `TOPATH` (`stdout` if not supplied). `write [FROMPATH] <TOPATH>`. Write a file from `FROMPATH` (`stdin` if not supplied) to `TOPATH`.
Project: Trivy (Provisioning / Security & Compliance)
File: elixir.md

Trivy supports repository for . The following scanners are supported. | Package manager | SBOM | Vulnerability | License | |--| :: | :--: |:-:| | | | | - | The following table provides an outline of the features Trivy offers. | Package manager | File | Transitive dependencies | Dev dependencies | | Position | |--|--|:--:|:-:|::|:--:| | | mix.lock[^1] | | Excluded | - | | In order to detect dependencies, Trivy searches for `mix.lock`[^1]. your project to use `mix.lock`[^1] file.
Project: KICS (Provisioning / Security & Compliance)
File: 0c79e50e-b3cf-490c-b8f6-587c644d4d0c.md

title: Operation Object Without 'consumes' hide: toc: true navigation: true <style> .highlight .hll { background-color: #ff171742; } .md-content { max-width: 1100px; margin: 0 auto; } </style> Query id: 0c79e50e-b3cf-490c-b8f6-587c644d4d0c Query name: Operation Object Without 'consumes' Platform: OpenAPI Severity: <span style="color:#ff7213">Medium</span> Category: Insecure Configurations URL: Operation Object should have 'consumes' feild defined for 'POST', 'PUT' and 'PATCH' operations<br> ```json title="Positive test num. 1 - json file" hl_lines="9" { "swagger": "2.0", "info": { "title": "Simple API Overview", "version": "1.0.0" }, "paths": { "/": { "put": { "operationId": "updateVersionsv2", "summary": "Update API versions", "produces": [ "application/json", "application/xml" ], "parameters": [] } } } } ``` ```yaml title="Positive test num. 2 - yaml file" hl_lines="7" swagger: "2.0" info: title: Simple API Overview version: 1.0.0 paths: "/": put: operationId: updateVersionsv2 summary: Update API versions produces: application/json application/xml parameters: [] ``` ```json title="Negative test num. 1 - json file" { "swagger": "2.0", "info": { "title": "Simple API Overview", "version": "1.0.0" }, "paths": { "/": { "put": { "operationId": "updateVersionsv2", "summary": "Update API versions", "produces": [ "application/json", "application/xml" ], "consumes": [ "application/x-www-form-urlencoded" ], "parameters": [] } } } } ``` ```yaml title="Negative test num. 2 - yaml file" swagger: "2.0" info: title: Simple API Overview version: 1.0.0 paths: "/": put: operationId: updateVersionsv2 summary: Update API versions produces: application/json application/xml consumes: application/x-www-form-urlencoded parameters: [] ```
Project: Meshery (Provisioning / Automation & Configuration)
File: v0.4.11.md

layout: release date: 2020-10-5 tag: v0.4.11 General [mesheryctl] Inform user of latest Meshery server version @leecalcote (#1640) Run Conformance Test through CLI @anirudhjain75 (#1554) Update README.md @thelovekesh (#1641) [Docs] Fixed the upgrade command syntax in the documentation @hexxdump (#1642)
Project: Flink (App Definition and Development / Streaming & Messaging)
File: trace_reporters.md

title: "Trace Reporters" weight: 7 type: docs aliases: /deployment/trace_reporters.html <!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> Flink allows reporting traces to external systems. For more information about Flink's tracing system go to the . Traces can be exposed to an external system by configuring one or several reporters in . These reporters will be instantiated on each job and task manager when they are started. Below is a list of parameters that are generally applicable to all reporters. All properties are configured by setting `traces.reporter.<reporter_name>.<property>` in the configuration. Reporters may additionally offer implementation-specific parameters, which are documented in the respective reporter's section. {{< includereporterconfig "layouts/shortcodes/generated/tracereporterssection.html" >}} All reporter configurations must contain the `factory.class` property. Example reporter configuration that specifies multiple reporters: ```yaml traces.reporters: otel,myotherotel traces.reporter.otel.factory.class: org.apache.flink.common.metrics.OpenTelemetryTraceReporterFactory traces.reporter.otel.exporter.endpoint: http://127.0.0.1:1337 traces.reporter.otel.scope.variables.additional: region:eu-west-1,environment:local-pnowojski-test,flink_runtime:1.17.1 traces.reporter.myotherotel.factory.class: org.apache.flink.common.metrics.OpenTelemetryTraceReporterFactory traces.reporter.myotherotel.exporter.endpoint: http://196.168.0.1:31337 ``` Important: The jar containing the reporter must be accessible when Flink is started. Reporters are loaded as . All reporters documented on this page are available by default. You can write your own `Reporter` by implementing the `org.apache.flink.traces.reporter.TraceReporter` and `org.apache.flink.traces.reporter.TraceReporterFactory` interfaces. Be careful that all the method must not block for a significant amount of time, and any reporter needing more time should instead run the operation asynchronously. The following sections list the supported reporters. Example configuration: ```yaml traces.reporter.slf4j.factory.class: org.apache.flink.traces.slf4j.Slf4jTraceReporterFactory ``` {{< top >}}
Project: CDK for Kubernetes (CDK8s) (Provisioning / Automation & Configuration)
File: helm.md

You can use the `Helm` construct in order to include charts. !!! note You will need helm to be locally for this feature. For accessing private helm repositories, you must be authenticated to the repository in a way that the `helm pull` command recognizes. The following example adds the Helm chart with sentinel containers enabled: The Bitnami helm repo needs to be added through: `helm repo add bitnami https://charts.bitnami.com/bitnami` ```ts class MyChart extends cdk8s.Chart { constructor(scope: Construct, id: string) { super(scope, id); const redis = new Helm(this, 'redis', { chart: 'bitnami/redis', values: { sentinel: { enabled: true } } }); } } ``` The `Helm` construct will render the manifest from the specified chart by executing `helm template`. If `values` is specified, these values will override the default values included with the chart. The `name` option can be used to specify the chart's . If not specified, a valid and unique release name will be allocated based on the construct path. The `Helm` construct extends `Include` and inherits it's API. For example, you can use the `apiObjects` property to find and interact with included API objects. The following example shows how to add an annotation to the Redis master deployment: ```ts const master = redis.apiObjects.find(o => o.name === 'foo-redis-master'); master.metadata.addAnnotation('my.annotation', 'hey-there'); ```
Project: YugabyteDB (App Definition and Development / Database)
File: ddl_drop_sequence.md

title: DROP SEQUENCE statement [YSQL] headerTitle: DROP SEQUENCE linkTitle: DROP SEQUENCE description: Use the DROP SEQUENCE statement to delete a sequence in the current schema. menu: v2.18: identifier: ddldropsequence parent: statements type: docs Use the `DROP SEQUENCE` statement to delete a sequence in the current schema. {{%ebnf%}} drop_sequence {{%/ebnf%}} Specify the name of the sequence. An error is raised if a sequence with that name does not exist in the current schema unless `IF EXISTS` is specified. An error is raised if any object depends on this sequence unless the `CASCADE` option is specified. Remove also all objects that depend on this sequence (for example a `DEFAULT` value in a table's column). Do not remove this sequence if any object depends on it. This is the default behavior even if it's not specified. Dropping a sequence that has an object depending on it, fails. ```plpgsql yugabyte=# CREATE TABLE t(k SERIAL, v INT); ``` ``` CREATE TABLE ``` ```plpgsql \d t ``` ``` Table "public.t" Column | Type | Collation | Nullable | Default --++--+-+ k | integer | | not null | nextval('tkseq'::regclass) v | integer | | | ``` ```plpgsql yugabyte=# DROP SEQUENCE tkseq; ``` ``` ERROR: cannot drop sequence tkseq because other objects depend on it DETAIL: default for table t column k depends on sequence tkseq HINT: Use DROP ... CASCADE to drop the dependent objects too. ``` Dropping the sequence with the `CASCADE` option solves the problem and also deletes the default value in table `t`. ```plpgsql yugabyte=# DROP SEQUENCE tkseq CASCADE; ``` ``` NOTICE: drop cascades to default for table t column k DROP SEQUENCE ``` ```plpgsql \d t ``` ``` Table "public.t" Column | Type | Collation | Nullable | Default --++--+-+ k | integer | | not null | v | integer | | | ```
Project: YDB (App Definition and Development / Database)
File: result_format_common.md

`pretty` (default): Human-readable format. `json-unicode`: [JSON]{% if lang == "ru" %}(https://ru.wikipedia.org/wiki/JSON){% endif %}{% if lang == "en" %}(https://en.wikipedia.org/wiki/JSON){% endif %} output with binary strings [Unicode]{% if lang == "ru" %}(https://ru.wikipedia.org/wiki/){% endif %}{% if lang == "en" %}(https://en.wikipedia.org/wiki/Unicode){% endif %}-encoded and each JSON string in a separate line. `json-unicode-array`: JSON output with binary strings Unicode-encoded and the result output as an array of JSON strings with each JSON string in a separate line.<li>`json-base64`: JSON output with binary strings [Base64]{% if lang == "ru" %}(https://ru.wikipedia.org/wiki/Base64){% endif %}{% if lang == "en" %}(https://en.wikipedia.org/wiki/Base64){% endif %}-encoded and each JSON string in a separate line. `json-base64-array`: JSON output with binary strings Base64-encoded and the result output as an array of JSON strings with each JSON string in a separate line; `parquet`: Output in format.
Project: Chef Infra (Provisioning / Automation & Configuration)
File: adding_documentation_to_infra_resources.md

The documentation for Infra Client resources resides at . Currently in order to reflect the documentation added to Infra Client resources on the we need to follow some manual steps. Clone . Install Hugo, npm, go. `brew tap go-swagger/go-swagger && brew install go-swagger hugo node go jq` The YAML data is generated using a task in the `chef/chef` repository. `rake docs_site:resources` The YAML files will be created under `docs_site` directory. Copy the corresponding file(s) for the resource(s) for which documentation is updated to . (NOTE: The data file(.yaml) should be verified and edited manually to remove any inaccuracies.) Go to the repository, where we copied the YAML file(s). Using the YAML file(s) create corresponding markdown(.md) file(s). `hugo new -k resource content/resources/RESOURCE_NAME.md` Run server locally and verify the changes in your browser at http://localhost:1313 `make serve` Once changes are verified, create a PR at repository.