import{_ as a,C as n,O as r,P as o,ah as s,Q as t,U as e,ai as d,aW as c}from"./framework-5638dcb2.js";const h={},l=c('<h1 id="quick-start" tabindex="-1"><a class="header-anchor" href="#quick-start" aria-hidden="true">#</a> Quick Start</h1><h2 id="about" tabindex="-1"><a class="header-anchor" href="#about" aria-hidden="true">#</a> About</h2><p>For applications based on time series data, data quality is vital. <strong>UDF Library</strong> is IoTDB User Defined Functions (UDF) about data quality, including data profiling, data quality evalution and data repairing. It effectively meets the demand for data quality in the industrial field.</p><h2 id="quick-start-1" tabindex="-1"><a class="header-anchor" href="#quick-start-1" aria-hidden="true">#</a> Quick Start</h2><ol><li>Download the JAR with all dependencies and the script of registering UDF.</li><li>Copy the JAR package to <code>ext\\udf</code> under the directory of IoTDB system.</li><li>Run <code>sbin\\start-server.bat</code> (for Windows) or <code>sbin\\start-server.sh</code> (for Linux or MacOS) to start IoTDB server.</li><li>Copy the script to the directory of IoTDB system (under the root directory, at the same level as <code>sbin</code>), modify the parameters in the script if needed and run it to register UDF.</li></ol><h2 id="download" tabindex="-1"><a class="header-anchor" href="#download" aria-hidden="true">#</a> Download</h2>',6),u={href:"https://thulab.github.io/iotdb-quality/en/Download.html",target:"_blank",rel:"noopener noreferrer"};function f(p,b){const i=n("ExternalLinkIcon");return r(),o("div",null,[s(`

​    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.

`),l,t("p",null,[e("Since our codes are still under review, there are no codes in Apache repository. Before finishing the review, the above files can be downloaded in our "),t("a",u,[e("old website"),d(i)]),e(".")])])}const g=a(h,[["render",f],["__file","Quick-Start.html.vue"]]);export{g as default};