import{_ as n,r as i,o as r,c as s,b as e,d as o,a,e as d}from"./app-BigCS_CO.js";const c={},l=e("h2",{id:"powered-by",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#powered-by"},[e("span",null,"Powered By")])],-1),p=e("h3",{id:"project-and-product-names-using-iotdb",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#project-and-product-names-using-iotdb"},[e("span",null,'Project and Product names using "IoTDB"')])],-1),h={href:"https://www.apache.org/foundation/marks/",target:"_blank",rel:"noopener noreferrer"},u={href:"https://www.apache.org/foundation/marks/faq/",target:"_blank",rel:"noopener noreferrer"},m=e("br",null,null,-1),g=e("br",null,null,-1),y=e("br",null,null,-1),f=e("h3",{id:"companies-and-organizations",tabindex:"-1"},[e("a",{class:"header-anchor",href:"#companies-and-organizations"},[e("span",null,"Companies and Organizations")])],-1),T=e("p",null,[o("To add yourself to the list, please email "),e("a",{href:"mailto:dev@iotdb.apache.org"},"dev@iotdb.apache.org"),o(" with your organization name, URL, a list of IoTDB components you are using, and a short description of your use case.")],-1),B={href:"https://github.com/apache/iotdb/discussions/4040",target:"_blank",rel:"noopener noreferrer"},w=d("<ul><li><p>School of Software (Tsinghua University), and National Engineering Laboratery for Big Data Software that initially launched IoTDB</p><ul><li>We have both graduate students and a team of professional software engineers working on the stack</li><li>We use Apache IoTDB in Shanghai Metro and two other cities in China to replace KairosDB.</li><li>We use Apache IoTDB in CMA (China Meteorological Administration) for storing 10-years station data. There are about 100 thousand stations.</li></ul></li><li><p>Lenovo developed TsFile Go version, and uses it in YOFC (Yangtze Optical Fiber and Cable Company). The system collects data from more than 90 thousand data points, stores them to the TsFile (with Go) as the edge storage and then reads them later to send to the cloud.</p></li><li><p>Goldwind uses Apache IoTDB to manage the wind turbine data. They consume the SCADA data from Kafka, write to IoTDB and use IoTDB to support queries.</p></li><li><p>DaTangXianYi deployed IoTDB in many power stations in China.</p></li><li><p>Beijing ZhiChuangXinKe uses IoTDB to store the battery data of signal towers for China Tower company. There are about 3 million towers.</p></li><li><p>Beijing QingZhiWuLian uses IoTDB for electric generator&#39;s monitoring. Currently they look forward to the cluster mode of IoTDB.</p></li><li><p>JianLongGangTie is testing IoTDB for using it in their applications.</p></li></ul>",1);function _(b,D){const t=i("ExternalLinkIcon");return r(),s("div",null,[l,p,e("p",null,[o("Organizations creating products and projects using Apache IoTDB, along with associated marketing materials, should take care to respect the trademark in “Apache IoTDB” and its logo. Please refer to "),e("a",h,[o("ASF Trademarks Guidance"),a(t)]),o(" and associated "),e("a",u,[o("FAQ"),a(t)]),o(" for comprehensive and authoritative guidance on proper usage of ASF trademarks."),m,o(" It is recommended to not include “IoTDB” in any names to prevent potential trademark issue with the IoTDB project."),g,o(' As an example, names like “IoTDB BigDataProduct” should not be used, as the name include “IoTDB” in general. The above links, however, describe some exceptions, like for names such as “BigDataProduct, powered by Apache IoTDB” or “BigDataProduct for Apache IoTDB”. In summary, any names contain "Apache IoTDB" as a whole are acceptable.'),y,o(" A common practice you can take is to create software identifiers (Maven coordinates, module names, etc.) like “iotdb-tool”. These are permitted. Nominative use of trademarks in descriptions is also allowed, as in “BigDataProduct is a subproduct for Apache IoTDB”.")]),f,T,e("p",null,[o("You can also leave the info on "),e("a",B,[o("Github"),a(t)]),o(".")]),w])}const I=n(c,[["render",_],["__file","Community-Powered-By.html.vue"]]),C=JSON.parse('{"path":"/Community/Community-Powered-By.html","title":"","lang":"en-US","frontmatter":{"description":"Powered By Project and Product names using \\"IoTDB\\" Organizations creating products and projects using Apache IoTDB, along with associated marketing materials, should take care t...","head":[["meta",{"property":"og:url","content":"https://iotdb.apache.org/Community/Community-Powered-By.html"}],["meta",{"property":"og:site_name","content":"IoTDB Website"}],["meta",{"property":"og:description","content":"Powered By Project and Product names using \\"IoTDB\\" Organizations creating products and projects using Apache IoTDB, along with associated marketing materials, should take care t..."}],["meta",{"property":"og:type","content":"article"}],["meta",{"property":"og:locale","content":"en-US"}],["meta",{"property":"og:updated_time","content":"2023-07-10T03:11:17.000Z"}],["meta",{"property":"article:modified_time","content":"2023-07-10T03:11:17.000Z"}],["script",{"type":"application/ld+json"},"{\\"@context\\":\\"https://schema.org\\",\\"@type\\":\\"Article\\",\\"headline\\":\\"\\",\\"image\\":[\\"\\"],\\"dateModified\\":\\"2023-07-10T03:11:17.000Z\\",\\"author\\":[]}"]]},"headers":[{"level":2,"title":"Powered By","slug":"powered-by","link":"#powered-by","children":[{"level":3,"title":"Project and Product names using \\"IoTDB\\"","slug":"project-and-product-names-using-iotdb","link":"#project-and-product-names-using-iotdb","children":[]},{"level":3,"title":"Companies and Organizations","slug":"companies-and-organizations","link":"#companies-and-organizations","children":[]}]}],"git":{"createdTime":1688958677000,"updatedTime":1688958677000,"contributors":[{"name":"CritasWang","email":"critas@outlook.com","commits":1}]},"readingTime":{"minutes":1.78,"words":535},"filePathRelative":"Community/Community-Powered-By.md","localizedDate":"July 10, 2023","autoDesc":true}');export{I as comp,C as data};
