cwielenb/CNCF-Dataset huggingface dataset:
Project: ClickHouse (App Definition and Development / Database)
File: iceberg.md

slug: /en/sql-reference/table-functions/iceberg sidebar_position: 90 sidebar_label: iceberg Provides a read-only table-like interface to Apache tables in Amazon S3. ``` sql iceberg(url [,awsaccesskeyid, awssecretaccesskey] [,format] [,structure]) ``` `url` Bucket url with the path to an existing Iceberg table in S3. `awsaccesskeyid`, `awssecretaccesskey` - Long-term credentials for the account user. You can use these to authenticate your requests. These parameters are optional. If credentials are not specified, they are used from the ClickHouse configuration. For more information see . `format` The of the file. By default `Parquet` is used. `structure` Structure of the table. Format `'column1name column1type, column2name column2type, ...'`. Engine parameters can be specified using . Returned value A table with the specified structure for reading data in the specified Iceberg table in S3. Example ```sql SELECT * FROM iceberg('http://test.s3.amazonaws.com/clickhouse-bucket/test_table', 'test', 'test') ``` :::important ClickHouse currently supports reading v1 (v2 support is coming soon!) of the Iceberg format via the `iceberg` table function and `Iceberg` table engine. ::: Here is an example of configuring a named collection for storing the URL and credentials: ```xml <clickhouse> <named_collections> <iceberg_conf> <url>http://test.s3.amazonaws.com/clickhouse-bucket/</url> <accesskeyid>test<accesskeyid> <secretaccesskey>test</secretaccesskey> <format>auto</format> <structure>auto</structure> </iceberg_conf> </named_collections> </clickhouse> ``` ```sql SELECT * FROM iceberg(icebergconf, filename = 'testtable') DESCRIBE iceberg(icebergconf, filename = 'testtable') ``` See Also
Project: YugabyteDB (App Definition and Development / Database)
File: ddl_alter_schema.md

title: ALTER SCHEMA statement [YSQL] headerTitle: ALTER SCHEMA linkTitle: ALTER SCHEMA description: Use the ALTER SCHEMA statement to change the definition of a schema. menu: stable: identifier: ddlalterschema parent: statements type: docs Use the `ALTER SCHEMA` statement to change the definition of a schema. {{%ebnf%}} alter_schema {{%/ebnf%}} ALTER SCHEMA changes the definition of a schema. In order to use `ALTER SCHEMA`, you need to be the owner of the schema. Renaming a schema requires having the `CREATE` privilege for the database. If you want to change the owner, you must also be a direct or indirect member of the new owning role, and you need to have the `CREATE` privilege for the database. (It's worth noting that superusers possess these privileges by default.) Specify the name of the schema (schema_name). An error is raised if a schema with that name does not exist in the current database. The name of the schema. Rename the schema. Schema names must not begin with `pg_`. The attempt to create a schema with such a name, or to rename an existing schema to have such a name, causes an error. Change the owner of the schema. The new owner of the schema. Username of current execution context. Username of current session. Create a simple schema. ```plpgsql yugabyte=# CREATE SCHEMA schema22; ``` ``` CREATE SCHEMA ``` Rename the schema. ```plpgsql yugabyte=# ALTER SCHEMA schema22 RENAME TO schema25; ``` ``` ALTER SCHEMA ``` ```plpgsql yugabyte=# \dn ``` ``` List of schemas Name | Owner -+- public | postgres schema25 | yugabyte (2 rows) ``` Change the owner of the schema. ```plpgsql yugabyte=# ALTER SCHEMA schema25 OWNER TO postgres; ``` ``` ALTER SCHEMA ``` ```plpgsql yugabyte=# \dn ``` ``` List of schemas Name | Owner -+- public | postgres schema25 | postgres (2 rows) ```
Project: ShardingSphere (App Definition and Development / Database)
File: show-dist-variable.en.md

+++ title = "SHOW DIST VARIABLE" weight = 8 +++ The `SHOW DIST VARIABLE` syntax is used to query `PROXY` system variables configuration. {{< tabs >}} {{% tab name="Grammar" %}} ```sql ShowDistVariable ::= 'SHOW' 'DIST' ('VARIABLES' ('LIKE' likePattern)?| 'VARIABLE' 'WHERE' 'NAME' '=' variableName) likePattern ::= string variableName ::= identifier ``` {{% /tab %}} {{% tab name="Railroad diagram" %}} <iframe frameborder="0" name="diagram" id="diagram" width="100%" height="100%"></iframe> {{% /tab %}} {{< /tabs >}} | Columns | Description | |-|--| | variable_name | system variable name | | variable_value | system variable value | When `variableName` is not specified, the default is query all `PROXY` variables configuration. Query all system variables configuration of `PROXY` ```sql SHOW DIST VARIABLES; ``` ```sql mysql> SHOW DIST VARIABLES; ++--+ | variablename | variablevalue | ++--+ | agentpluginsenabled | true | | cached_connections | 0 | | cdcserverport | 33071 | | checktablemetadata_enabled | false | | kernelexecutorsize | 0 | | maxconnectionssizeperquery | 1 | | proxybackendqueryfetchsize | -1 | | proxydefaultport | 3307 | | proxyfrontenddatabaseprotocoltype | | | proxyfrontendexecutor_size | 0 | | proxyfrontendflush_threshold | 128 | | proxyfrontendmax_connections | 0 | | proxyfrontendssl_cipher | | | proxyfrontendssl_enabled | false | | proxyfrontendssl_version | TLSv1.2,TLSv1.3 | | proxymetadatacollectorenabled | true | | proxynettybacklog | 1024 | | sqlfederationtype | NONE | | sql_show | false | | sql_simple | false | | systemloglevel | INFO | ++--+ 21 rows in set (0.01 sec) ``` Query specified system variable configuration of `PROXY` ```sql SHOW DIST VARIABLE WHERE NAME = sql_show; ``` ```sql mysql> SHOW DIST VARIABLE WHERE NAME = sql_show; ++-+ | variablename | variablevalue | ++-+ | sql_show | false | ++-+ 1 row in set (0.00 sec) ``` `SHOW`, `DIST`, `VARIABLE`, `VARIABLES`, `NAME`
Project: ShardingSphere (App Definition and Development / Database)
File: hint.en.md

+++ title = "Hint" weight = 1 +++ Apache ShardingSphere uses ThreadLocal to manage sharding key values for mandatory routing. A sharding value can be added by programming to the HintManager that takes effect only within the current thread. Main application scenarios for Hint: The sharding fields do not exist in the SQL and database table structure but in the external business logic. Certain data operations are forced to be performed in given databases. Call HintManager.getInstance() to obtain an instance of HintManager. Use HintManager.addDatabaseShardingValue, HintManager.addTableShardingValue to set the sharding key value. Execute SQL statements to complete routing and execution. Call HintManager.close to clean up the contents of ThreadLocal. Hint algorithms require users to implement the interface of `org.apache.shardingsphere.api.sharding.hint.HintShardingAlgorithm`. Apache ShardingSphere will acquire sharding values from HintManager to route. Take the following configurations for reference: ```yaml rules: !SHARDING tables: t_order: actualDataNodes: demods${0..1}.torder${0..1} databaseStrategy: hint: algorithmClassName: xxx.xxx.xxx.HintXXXAlgorithm tableStrategy: hint: algorithmClassName: xxx.xxx.xxx.HintXXXAlgorithm defaultTableStrategy: none: defaultKeyGenerateStrategy: type: SNOWFLAKE column: order_id props: sql-show: true ``` ```java HintManager hintManager = HintManager.getInstance(); ``` Use `hintManager.addDatabaseShardingValue` to add sharding key value of data source. Use `hintManager.addTableShardingValue` to add sharding key value of table. Users can use `hintManager.setDatabaseShardingValue` to set sharding value in hint route to some certain sharding database without sharding tables. Sharding values are saved in `ThreadLocal`, so it is necessary to use `hintManager.close()` to clean `ThreadLocal`. `HintManager` has implemented `AutoCloseable`. We recommend to close it automatically with `try with resource`. ```java // Sharding database and table with HintManager String sql = "SELECT * FROM t_order"; try (HintManager hintManager = HintManager.getInstance(); Connection conn = dataSource.getConnection(); PreparedStatement preparedStatement = conn.prepareStatement(sql)) { hintManager.addDatabaseShardingValue("t_order", 1); hintManager.addTableShardingValue("t_order", 2); try (ResultSet rs = preparedStatement.executeQuery()) { while (rs.next()) { // ... } } } // Sharding database and one database route with HintManager String sql = "SELECT * FROM t_order"; try (HintManager hintManager = HintManager.getInstance(); Connection conn = dataSource.getConnection(); PreparedStatement preparedStatement = conn.prepareStatement(sql)) { hintManager.setDatabaseShardingValue(3); try (ResultSet rs = preparedStatement.executeQuery()) { while (rs.next()) { // ... } } } ```
Project: CDK for Kubernetes (CDK8s) (Provisioning / Automation & Configuration)
File: installation.md

This page describes the different ways you can install the Cloud Development Kit for Kubernetes (cdk8s) command-line interface (CLI) tool on your local machine. To install the cdk8s CLI with , run the following command: ```console brew install cdk8s ``` To install the cdk8s CLI with , run the following command: ```console npm i -g cdk8s-cli ``` To install the cdk8s CLI with , run the following command: ```console yarn global add cdk8s-cli ``` To check your version, run the following command: ```console cdk8s --version ``` You should see something similar to the following: ``` 2.2.31 ```
Project: Ansible (Provisioning / Automation & Configuration)
File: guide_newbie_about_gh_and_contributing_to_ansible.md

@{{ paste.handle.here }} it seems to me that you are new to GitHub and have created this accidentally. That's why I'm closing it. But no worries! Welcome to the Ansible community :) Assuming that you wanted to create actual contribution, I think that you may want to learn and read through the following articles I've gathered for you: <https://opensource.guide/how-to-contribute/> <https://docs.ansible.com/ansible/devel/community/> Because this project is very active, we're unlikely to see comments made on closed tickets and we lock them after some time. If you or anyone else has any further questions, please let us know by using any of the communication methods listed in the page below: <https://docs.ansible.com/ansible/latest/community/communication.html> Have a nice day!
Project: ClickHouse (App Definition and Development / Database)
File: v23.4.6.25-stable.md

sidebar_position: 1 sidebar_label: 2023 Backported in : Improve the progress bar for file/s3/hdfs/url table functions by using chunk size from source data and using incremental total size counting in each thread. Fix the progress bar for Cluster functions. This closes . (). Fix backward compatibility for IP types hashing in aggregate functions (). Fix segfault in MathUnary (). Fix for moving 'IN' conditions to PREWHERE (). Fix reading from empty column in `parseSipHashKey` (). Allow parametric UDFs (). Decoupled commits from for backports (). Fix MergeTreeMarksLoader segfaulting if marks file is longer than expected (). Fix source image for sqllogic ().
Project: Lagoon (App Definition and Development / Application Definition & Image Build)
File: deploy-project.md

Run the following command to deploy your project: ```bash title="Deploy" lagoon deploy branch -p <YOUR-PROJECT-NAME> -b <YOUR-BRANCH-NAME> ``` Go to the Lagoon UI and take a look at your project - you should now see the environment for this project! Look in your cluster at your pods list, and you should see the build pod as it begins to clone Git repositories, set up services, etc. ```bash title="See all pods" kubectl get pods --all-namespaces | grep lagoon-build ```
Project: TDengine (App Definition and Development / Database)
File: general-questions.md

name: General Questions about: General questions about TDengine's usage, user experiences, milestones etc. title: '' labels: help wanted, question assignees: '' General Questions A general question should be related to TDengine's user's manual, user experience, milestones, business cooperations etc. Before you ask a question, please: Try searching for answers in the official documentation Try searching in the existing issues on GitHub Try searching on tech forums such as Stack Overflow, Quora, CSDN, v2ex etc. Try using online searching engines such as Google, Bing, Baidu If all the ways above couldn't help, please clearly and concisely describe what the question is.
Project: Meshery (Provisioning / Automation & Configuration)
File: virtual-kubelet.md

layout: integration title: Virtual Kubelet subtitle: Collaborative and visual infrastructure as code for Virtual Kubelet image: /assets/img/integrations/virtual-kubelet/icons/color/virtual-kubelet-color.svg permalink: extensibility/integrations/virtual-kubelet docURL: https://docs.meshery.io/extensibility/integrations/virtual kubelet description: integrations-category: Serverless integrations-subcategory: Installable Platform 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: Apache Hadoop (App Definition and Development / Database)
File: leaserecoverable.md

<! Licensed 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. See accompanying LICENSE file. --> The `LeaseRecoverable` interface tells whether a given path of current filesystem can perform lease recovery for open file that a lease is not explicitly renewed or the client holding it goes away. This interface should be implemented accordingly when necessary to any Filesystem that supports lease recovery, e.g. `DistributedFileSystem` (HDFS) and `ViewDistributedFileSystem`. ```java public interface LeaseRecoverable { boolean recoverLease(Path file) throws IOException; boolean isFileClosed(Path file) throws IOException; } ``` There are two main functions of this interface, one performs lease recovery and another one verifies if a file has been closed. This function performs the lease recovery for the given file path, and it does not support directory path recovery. Return `true`, if the file has already closed, or does not require lease recovery. Return `false`, if the lease recovery is yet completed. Throw `IOException` if a directory path is given as input. This function only checks if the give file path has been closed, and it does not support directory verification. Return `true`, if the file has been closed. Return `false`, if the file is still open. Throw `IOException` if a directory path is given as input. If a filesystem supports `LeaseRecoverable`, it should return `true` to `PathCapabilities.hasPathCapability(path, "fs.capability.lease.recoverable")` for a given path.
Project: Flink (App Definition and Development / Streaming & Messaging)
File: packaging.md

title: Program Packaging weight: 21 type: docs bookToc: false aliases: /dev/packaging.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. --> As described earlier, Flink programs can be executed on clusters by using a `remote environment`. Alternatively, programs can be packaged into JAR Files (Java Archives) for execution. Packaging the program is a prerequisite to executing them through the . To support execution from a packaged JAR file via the command line or web interface, a program must use the environment obtained by `StreamExecutionEnvironment.getExecutionEnvironment()`. This environment will act as the cluster's environment when the JAR is submitted to the command line or web interface. If the Flink program is invoked differently than through these interfaces, the environment will act like a local environment. To package the program, simply export all involved classes as a JAR file. The JAR file's manifest must point to the class that contains the program's entry point (the class with the public `main` method). The simplest way to do this is by putting the main-class entry into the manifest (such as `main-class: org.apache.flinkexample.MyProgram`). The main-class attribute is the same one that is used by the Java Virtual Machine to find the main method when executing a JAR files through the command `java -jar pathToTheJarFile`. Most IDEs offer to include that attribute automatically when exporting JAR files. The overall procedure to invoke a packaged program consists of two steps: The JAR's manifest is searched for a main-class or program-class attribute. If both attributes are found, the program-class attribute takes precedence over the main-class attribute. Both the command line and the web interface support a parameter to pass the entry point class name manually for cases where the JAR manifest contains neither attribute. The system invokes the main method of the class. {{< top >}}
Project: YugabyteDB (App Definition and Development / Database)
File: ddl_create_schema.md

title: CREATE SCHEMA statement [YSQL] headerTitle: CREATE SCHEMA linkTitle: CREATE SCHEMA description: Use the CREATE SCHEMA statement to create schema in the current database. menu: v2.18: identifier: ddlcreateschema parent: statements type: docs Use the `CREATE SCHEMA` statement to create a schema in the current database. A schema is essentially a namespace: it contains named objects (tables, data types, functions, and operators) whose names can duplicate those of objects in other schemas. Named objects in a schema can be accessed by using the schema name as prefix or by setting the schema name in the search path. {{%ebnf%}} createschemaname, createschemarole, role_specification {{%/ebnf%}} Where `schemaname` is the name of the schema being created. If no schemaname is specified, the `role_name` is used. `role_name` is the role who will own the new schema. If omitted, it defaults to the user executing the command. To create a schema owned by another role, you must be a direct or indirect member of that role, or be a superuser. `schema_element` is a YSQL statement defining an object to be created within the schema. Currently, only , , , , and are supported as clauses within `CREATE SCHEMA`. Other kinds of objects may be created in separate commands after the schema is created. Create a schema. ```plpgsql yugabyte=# CREATE SCHEMA IF NOT EXISTS branch; ``` Create a schema for a user. ```plpgsql yugabyte=# CREATE ROLE John; yugabyte=# CREATE SCHEMA AUTHORIZATION john; ``` Create a schema that will be owned by another role. ```plpgsql yugabyte=# CREATE SCHEMA branch AUTHORIZATION john; ```
Project: RBAC Manager (Provisioning / Security & Compliance)
File: upgrades.md

RBAC Manager 0.4.0 was a huge release that unfortunately included some significant breaking changes. To our knowledge, we're the only ones that have been using this project up to this point, but we certainly still do not take breaking changes lightly. We hope that the advantages it provides are worth the upgrade effort. This version involves a transition from Python to Go + Kubebuilder. There are a number of advantages included in this move: Improved testing capabilities with client-go Decreases Docker image size by 2/3 Encourages usage of best practices through framework usage Strong typing should help avoid introducing stupid bugs Potential for generating docs with Kubebuilder Beyond those benefits, here are the key new changes involved with this release: New RBAC Definition syntax Support for multiple RBAC Definitions Using OwnerReferences to associate a specific RBAC Definition with a Cluster Role Binding, Role Binding, or Service Account Using CRD validation for all RBAC Definition fields Moving from rbac-manager.reactiveops.io to rbacmanager.reactiveops.io for CRD Support for groups (helpful when working with something like Heptio Authenticator) Some basic testing in place Unfortunately with the changes to the custom resource definition, this process will essentially involve deleting the previous configuration and creating new replacement configuration with the updated syntax. Before beginning this process, ensure that you have cluster-admin access that is not managed by RBAC Manager. Part of this process will involve temporarily deleting those roles, so it's important to ensure you have cluster-admin access through a separate Cluster Role Binding. Delete any existing RBAC Definitions - this allows the original RBAC Manager version to delete any associated role bindings. Delete the RBAC Manager deployment configuration. Deploy the updated version of RBAC Manager. Create an updated RBAC Definition with the new syntax (see the `examples` directory of this repository).
Project: kpt (Provisioning / Automation & Configuration)
File: 04-rendering-a-package.md

Regardless of how you have edited the package, you want to render the package: ```shell $ kpt fn render wordpress ``` ?> Refer to the for usage. `render` is a critical step in the package lifecycle. At a high level, it perform the following steps: Enforces package preconditions. For example, it validates the `Kptfile`. Executes functions declared in the package hierarchy in a depth-first order. By default, the packages are modified in-place. Guarantees package postconditions. For example, it enforces a consistent formatting of resources, even though a function (developed by different people using different toolchains) may have modified the formatting in some way. [Chapter 4] discusses different ways of running functions in detail.
Project: Open Policy Agent (OPA) (Provisioning / Security & Compliance)
File: conftest.md

title: Conftest subtitle: Rego policy for configuration files labels: type: poweredbyopa layer: configuration code: https://github.com/open-policy-agent/conftest software: kustomize terraform aws toml docker tutorials: https://www.conftest.dev https://www.conftest.dev/examples/ videos: title: Applying Policy Throughout the Application Lifecycle with Open Policy Agent speakers: name: Gareth Rushgrove organization: snyk venue: Kubecon San Diego 2019 link: https://www.youtube.com/watch?v=cXfsaE6RKfc title: 'Terraform Code Reviews: Supercharged with Conftest' speakers: name: Jay Wallace organization: doordash venue: Hashitalks 2020 link: https://www.youtube.com/watch?v=ziKT-ZjZ7mM docs_features: policy-testing: note: | Conftest supports unit testing of policy and has a number of extra language features for working with configuration files. The functionality is . go-integration: note: | Conftest is written in Go and uses the . opa-bundles: note: | Conftest supports the loading of policy in a bundle format. The feature is . terraform: note: | Conftest has generic support for Terraform source files defined in HCL. There is an example provided here on . Conftest is a utility built on top of OPA to help you write tests against structured configuration data.