精华内容
下载资源
问答
  • Titan图数据库安装文件titan-1.0.0-hadoop1.zip
  • Titan图形数据库的应用实例讲解

    千次阅读 2017-10-13 15:12:35
    这篇《Titan数据库快速入门之神的光芒》同事已经详细介绍了Titan数据库的安装与使用,这里不再赘述。此篇博客介绍Titan的实际应用与成果展示,方便读者更好的理解Titan。项目背景本项目基于工程大数据进行研究,下...

    前言

    因公司业务发展,需要建立完整的关系图谱检索系统。经各种比较与考量,我们采用Titan图形数据库来处理复杂的逻辑关系。这篇《Titan数据库快速入门之神的光芒》同事已经详细介绍了Titan数据库的安装与使用,这里不再赘述。此篇博客介绍Titan的实际应用与成果展示,方便读者更好的理解Titan。

    项目背景

    本项目基于工程大数据进行研究,下图为Hbase中的部分数据展示。通常,一个工程项目有一个或者多个标段,这些标段分别由不同的公司完成,也存在同一标段由多家公司联合完成的情况。例如,图中所示,上海公路桥梁(集团)有限公司完成了合肥至六安高速公路这一项目的路基十三标的施工。而合肥至六安高速公路下面的剩余标段分别由其他家公司完成,因此,施工公司、项目、标段就串成了一个关系图谱,用Titan数据库存储时对应图中的边和点关系。

    这里写图片描述

    项目实施

    1、关系图谱存入Titan数据库中

    Hbase中已经存入了近几年多家工程公司的业绩信息,但每个施工业绩都是独立的,没有建成一张关系图谱。所以首先,根据采集的数据构建一个关系图谱存入Titan数据库中。虽然是Titan数据库,但我们采用Hbase进行存储。
    下面代码完成的任务是:
    从表CompanyInfos_test中遍历所有公司的业绩信息,获取该公司名字,存为结点v1,并添加属性group=1;获取标段,存为结点v2,group=2;并在公司和标段之间建立一条边;获取项目名字,存为结点v3,group=3;并在项目和标段之间建立一条边;重复上述过程,即可建立一张所有公司、标段、项目串起来的关系图表,并存入Hbase中。

    Java代码 

    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
     /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    package com.rednum.graph;
    
    import com.google.gson.Gson;
    import com.google.gson.internal.LinkedTreeMap;
    import static com.rednum.graph.CompanyCountry.conf;
    import static com.rednum.graph.TiTanDB.INDEX_NAME;
    import static com.rednum.graph.TiTanDB.load;
    import static com.rednum.graph.TiTanDB.query;
    import com.thinkaurelius.titan.core.EdgeLabel;
    import com.thinkaurelius.titan.core.Multiplicity;
    import com.thinkaurelius.titan.core.PropertyKey;
    import com.thinkaurelius.titan.core.TitanFactory;
    import com.thinkaurelius.titan.core.TitanGraph;
    import com.thinkaurelius.titan.core.TitanTransaction;
    import com.thinkaurelius.titan.core.attribute.Geoshape;
    import com.thinkaurelius.titan.core.attribute.Text;
    import com.thinkaurelius.titan.core.schema.ConsistencyModifier;
    import com.thinkaurelius.titan.core.schema.TitanGraphIndex;
    import com.thinkaurelius.titan.core.schema.TitanManagement;
    import com.thinkaurelius.titan.core.util.TitanCleanup;
    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import org.apache.commons.configuration.BaseConfiguration;
    import org.apache.commons.configuration.Configuration;
    import org.apache.hadoop.hbase.Cell;
    import org.apache.hadoop.hbase.CellUtil;
    import org.apache.hadoop.hbase.HBaseConfiguration;
    import org.apache.hadoop.hbase.HConstants;
    import org.apache.hadoop.hbase.client.Get;
    import org.apache.hadoop.hbase.client.HTable;
    import org.apache.hadoop.hbase.client.Result;
    import org.apache.hadoop.hbase.client.ResultScanner;
    import org.apache.hadoop.hbase.client.Scan;
    import org.apache.hadoop.hbase.util.Bytes;
    import org.apache.tinkerpop.gremlin.process.traversal.Order;
    import org.apache.tinkerpop.gremlin.process.traversal.P;
    import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
    import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
    import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
    import org.apache.tinkerpop.gremlin.structure.Direction;
    import org.apache.tinkerpop.gremlin.structure.Edge;
    import org.apache.tinkerpop.gremlin.structure.T;
    import org.apache.tinkerpop.gremlin.structure.Vertex;
    import org.codehaus.jettison.json.JSONArray;
    import org.codehaus.jettison.json.JSONObject;
    
    /**
     *
     * @author X.H.Yang
     */
    public class TiTanNew {
    
        public static final String INDEX_NAME = "search";
        public static org.apache.hadoop.conf.Configuration conf = null;
    
        static {
            conf = HBaseConfiguration.create();
            conf.setLong(HConstants.HBASE_REGIONSERVER_LEASE_PERIOD_KEY, 180000);
        }
    
        public static TitanGraph create() {
            try {
                //创建名为newgraph的表。
                TitanGraph graph = TitanFactory.build()
                        .set("storage.backend", "hbase")
                        .set("storage.hostname", "192.168.1.252")
                        .set("storage.hbase.table", "newgraph")
                        .set("cache.db-cache", "true")
                        .set("cache.db-cache-clean-wait", "20")
                        .set("cache.db-cache-time", "180000")
                        .set("cache.db-cache-size", "0.5")
                        .set("index.newgraph.backend", "elasticsearch")
                        .set("index.newgraph.hostname", "192.168.1.212")
                        .set("index.newgraph.port", 9300)
                        .set("index.newgraph.elasticsearch.client-only", true)
                        .open();
                return graph;
            } catch (Exception e) {
                System.out.println(e);
                return null;
            }
        }
    
        public static void loadWithoutMixedIndex(final TitanGraph graph,
                boolean uniqueNameCompositeIndex) {
            load(graph, null, uniqueNameCompositeIndex);
        }
    
        public static void load(final TitanGraph graph) {
            load(graph, "newgraph", true);
        }
    
        public static void load(final TitanGraph graph, String mixedIndexName,
                boolean uniqueNameCompositeIndex) {
            // 添加索引,name为key,并建立边和点的联合索引,提高查询速率
            try {
                TitanManagement mgmt = graph.openManagement();
                final PropertyKey name = mgmt.makePropertyKey("name").dataType(String.class).make();
                TitanManagement.IndexBuilder nameIndexBuilder = mgmt.buildIndex("name", Vertex.class).addKey(name);
                if (uniqueNameCompositeIndex) {
                    nameIndexBuilder.unique();
                }
                TitanGraphIndex namei = nameIndexBuilder.buildCompositeIndex();
                mgmt.setConsistency(namei, ConsistencyModifier.LOCK);
                final PropertyKey group = mgmt.makePropertyKey("group").dataType(Integer.class).make();
                if (null != mixedIndexName) {
                    mgmt.buildIndex("vertices", Vertex.class).addKey(group).buildMixedIndex(mixedIndexName);
                }
                final PropertyKey projectname = mgmt.makePropertyKey("projectname").dataType(String.class).make();
                final PropertyKey sectionname = mgmt.makePropertyKey("sectionname").dataType(String.class).make();
                if (null != mixedIndexName) {
                    mgmt.buildIndex("edges", Edge.class).addKey(projectname).addKey(sectionname).buildMixedIndex(mixedIndexName);
                }
                mgmt.makeEdgeLabel("ComSec").multiplicity(Multiplicity.MANY2ONE).make();
                mgmt.makeEdgeLabel("SecPro").multiplicity(Multiplicity.MANY2ONE).make();
                mgmt.commit();
    
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    
        public void doCreatCompanyGraph() {
            TitanGraph graph = create(); //建立表
            load(graph);  //添加索引
            GraphTraversalSource g = graph.traversal(); //遍历表
            String error = "";
            while (true) {
                try {
                    //遍历采集的数据CompanyInfos_test表中所有公司名字
                    HTable country = new HTable(conf, "CompanyInfos_test");
                    Scan s = new Scan();
                    ResultScanner rs = country.getScanner(s);
                    int count = 0;
                    for (Result r : rs) {
                        count++;
                        String row = Bytes.toString(r.getRow());
                        error = row;
                        //避免同一公司重复加入图谱,name设为索引key,只能唯一存在
                        if (g.V().has("group", 1).has("name", row).hasNext()) {
                            continue;
                        }
    
                        //建立公司名称节点,属性有label, name, group, 即公司名字的group为1,label为company
                        Vertex v1 = graph.addVertex(T.label, "company", "name", row, "group", 1);
    
                        //Hbase相关查询语句,根据rowkey获取指定列族里所有列
                        Get get = new Get(Bytes.toBytes(row));
                        get.addFamily(Bytes.toBytes("performance_owner"));
                        Result rs1 = country.get(get);
                        for (Cell cell : rs1.rawCells()) {
                            String performance = "";
                            String project = "";
                            performance = Bytes.toString(CellUtil.cloneValue(cell));
                            project = getProjectByPer(performance);
                            if (!"".equals(performance)) {
                                performance = performance.replace(row, "");
                            }
                            if (!"".equals(project)) {
                                performance = performance.replace(project, "");
                            }
                            if ("/".equals(performance) || "".equals(performance)) {
                                performance = project;
                            }
                            Vertex v2 = null;
                            if (!"".equals(performance)) {
                                 //建立标段节点,属性有label, sectionname, group, 即标段的group为2,label为section
                                v2 = graph.addVertex(T.label, "section", "sectionname", performance, "group", 2);
                                //添加一条由v1指向v2,属性为ComSec的边
                                v1.addEdge("ComSec", v2);
                            }
                            if (!"".equals(project)) {
                                Vertex v3 = null;
                                if (g.V().has("group", 3).has("projectname", project).hasNext()) {
                                    v3 = g.V().has("group", 3).has("projectname", project).next();
                                } else {
                                    v3 = graph.addVertex(T.label, "project", "projectname", project, "group", 3);
                                }
                                v2.addEdge("SecPro", v3);
                            }
                            graph.tx().commit();
    
                        }
                        graph.tx().commit();
                        System.out.println(row + ": 第" + count + "家公司");
    
                    }
                    rs.close();
                    System.out.println("共有数据" + count);
                    break;
                } catch (Exception e) {
                    System.out.println(e.toString());
                    System.out.println("公司:" + error + "捕获异常");
                    //对异常的结点进行删除
                    Vertex ver = g.V().has("group", 1).has("name", error).next();
                    GraphTraversal<Vertex, Vertex> mF = g.V(ver).out("ComSec");
                    while (mF.hasNext()) {
                        Vertex ver1 = mF.next();
                        g.V(ver1).drop().iterate(); //删除该节点
                    }
                    g.V(ver).drop().iterate();
                    graph.tx().commit();
                    continue;
                }
            }
            System.out.println(g.V().count().next());
            System.out.println(g.E().count().next());
            graph.close();
        }
    
        public String getProjectByPer(String per) throws IOException {
            HTable table = new HTable(conf, "CompanyOwner_test");
            Get get = new Get(per.getBytes("utf-8"));
            get.addColumn(Bytes.toBytes("ProjectInfo"), Bytes.toBytes("ProjectName"));
            Result rs = table.get(get);
            String project = "";
            for (Cell cell : rs.rawCells()) {
                project = Bytes.toString(CellUtil.cloneValue(cell));
            }
            return project;
    
        }
    
        public static void main(String[] args) throws Exception {
            try {
                TiTanNew titan = new TiTanNew();
                titan.doCreatCompanyGraph();
    
            } catch (Exception e) {
                e.toString();
            }
        }
    }

    2、关系检索

    下面给出模糊搜索项目:“遵义至毕节高速公路”的实现过程。

    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    package com.rednum.graph;
    
    import com.google.gson.Gson;
    import com.thinkaurelius.titan.core.TitanException;
    import com.thinkaurelius.titan.core.TitanFactory;
    import com.thinkaurelius.titan.core.TitanGraph;
    import com.thinkaurelius.titan.core.TitanVertex;
    import com.thinkaurelius.titan.core.attribute.Text;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.NoSuchElementException;
    import java.util.Set;
    import org.apache.commons.configuration.BaseConfiguration;
    import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
    import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
    import org.apache.tinkerpop.gremlin.structure.Direction;
    import org.apache.tinkerpop.gremlin.structure.Vertex;
    
    /**
     *
     * @author X.H.Yang
     */
    public class CompanyCountrySearch {
    
        private Gson gson = new Gson();
    
        public static TitanGraph open() {
            try {
                org.apache.commons.configuration.Configuration conf = new BaseConfiguration();
                conf.setProperty("storage.backend", "hbase");
                conf.setProperty("storage.hostname", "192.168.1.252");
                conf.setProperty("storage.hbase.table", "newgraph");
                TitanGraph graph = TitanFactory.open(conf);
                return graph;
            } catch (Exception e) {
                System.out.println(e);
                return null;
            }
        }
    
        public String doSearch() {
            TitanGraph graph = CompanyCountrySearch.open();
            GraphTraversalSource g = graph.traversal();
            try {
                String jstr = "";
                Iterable<TitanVertex> mm = graph.query().has("group", 3).has("projectname", Text.REGEX, ".*遵义至毕节高速公路.*").vertices();
                for (TitanVertex tt : mm) {
                    HashMap<String, Object> params = new HashMap<>();
                    List<Map> nodes = new ArrayList<>();
                    List<Object> links = new ArrayList<>();
                    Map map = new LinkedHashMap();
                    GraphTraversal<Vertex, Vertex> mF = g.V(tt).in("SecPro");
                    String project = g.V(tt).next().value("projectname");
                    System.out.println("工程名称:" + project);
                    map.put("name", project);
                    map.put("group", 1);
                    map.put("index", nodes.size());
                    nodes.add(map);
                    int i = 0;
    
                    while (mF.hasNext()) {
    
                        Vertex v1 = mF.next();
                        String section = g.V(v1).next().value("sectionname");
    
                        Vertex v2 = g.V(v1).in("ComSec").next();
                        String company = g.V(v2).next().value("name");
    
                        Map map1 = new LinkedHashMap();
                        map1.put("name", section);
                        map1.put("group", 2);
                        map1.put("index", nodes.size());
                        nodes.add(map1);
                        i = i+1;
    
                        Map link1 = new LinkedHashMap();
                        link1.put("source", nodes.size()-1);
                        link1.put("target", 0);
                        links.add(link1);
    
                        int temp = 0;
                        int kk = 0;
                        for (Map m : nodes) {
                            if (m.containsValue(company)) {
                                kk = (int) m.get("index");
                                temp = 1;
                                break;
                            }
                        }
    
                        if (temp == 1) {
                            Map templink = new LinkedHashMap();
                            templink.put("source", kk);
                            templink.put("target", nodes.size()-1);
                            links.add(templink);
    
                        } else {
                            Map map2 = new LinkedHashMap();
                            map2.put("name", company);
                            map2.put("group", 3);
                            map2.put("index", nodes.size());
                            nodes.add(map2);
    
                            Map link2 = new LinkedHashMap();
                            link2.put("source", nodes.size()-1 );
                            link2.put("target", nodes.size()-2);
                            links.add(link2);
    
                            i = i + 1;
                            System.out.println("----------");
    
                            GraphTraversal<Vertex, Vertex> gt = g.V(v2).out("ComSec");
    
                            int j = 0;
                            int count = nodes.size()-1;
                            while (gt.hasNext()) {
                                Vertex v3 = gt.next();
                                String section1 = g.V(v3).next().value("sectionname");
                                String project1 = g.V(v3).out("SecPro").next().value("projectname");
                                if (project1.equals(project)) {
                                    continue;
                                }
                                Map map11 = new LinkedHashMap();
                                map11.put("name", section1);
                                map11.put("group", 2);
                                map11.put("index", nodes.size());
                                nodes.add(map11);
                                j = j +1;
    
                                Map link11 = new LinkedHashMap();
                                link11.put("source", count);
                                link11.put("target", nodes.size()-1);
                                links.add(link11);
    
                                int temp1 = 0;
                                int kk1 = 0;
                                for (Map m : nodes) {
                                    if (m.containsValue(project1)) {
                                        kk1 = (int) m.get("index");
                                        temp1 = 1;
                                        break;
                                    }
                                }
    
                                if (temp1 == 1) {
    
                                    Map link22 = new LinkedHashMap();
                                    link22.put("source", nodes.size()-1);
                                    link22.put("target", kk1);
                                    links.add(link22);
    
    
                                } else {
                                    Map map22 = new LinkedHashMap();
                                    map22.put("name", project1);
                                    map22.put("group", 1);
                                    map22.put("index", nodes.size());
                                    nodes.add(map22);
    
                                    Map link22 = new LinkedHashMap();
                                    link22.put("source", nodes.size()-2);
                                    link22.put("target", nodes.size()-1);
                                    links.add(link22);
    
                                  j = j + 1;
                                }
                            }
                            i = i +j + 2;
    
                        }
    
                    }
                    params.put("nodes", nodes);
                    params.put("links", links);
                    jstr = gson.toJson(params);
                    System.out.println(jstr);
                    break;
                }
    
                graph.close();
                return jstr;
    
            } catch (NoSuchElementException | TitanException e) {
                e.toString();
                System.out.println(e.toString());
                return null;
            }
        }
    
        public static void main(String[] args) {
            CompanyCountrySearch search = new CompanyCountrySearch();
            search.doSearch();
    
        }
    
    }

    我们也可根据公司名字检索出相关联的项目和标段信息,代码如下:

    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    package com.rednum.graph;
    
    import com.google.gson.Gson;
    import com.thinkaurelius.titan.core.TitanFactory;
    import com.thinkaurelius.titan.core.TitanGraph;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    import org.apache.commons.configuration.BaseConfiguration;
    import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
    import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
    import org.apache.tinkerpop.gremlin.structure.Vertex;
    
    /**
     *
     * @author X.H.Yang
     */
    public class TitanSearchByCompany {
    
         private Gson gson = new Gson();
    
        public static TitanGraph open() {
            try {
                org.apache.commons.configuration.Configuration conf = new BaseConfiguration();
                conf.setProperty("storage.backend", "hbase");
                conf.setProperty("storage.hostname", "192.168.1.252");
                conf.setProperty("storage.hbase.table", "newgraph");
                TitanGraph graph = TitanFactory.open(conf);
                return graph;
            } catch (Exception e) {
                System.out.println(e);
                return null;
            }
        }
    
         public String searchBycom() {
           TitanGraph graph = open();
            GraphTraversalSource g = graph.traversal();
            try {
                HashMap<String, Object> params = new HashMap<>();
                List<Map> nodes = new ArrayList<>();
                List<Object> links = new ArrayList<>();
                GraphTraversal<Vertex, Vertex> mF = g.V().has("group", 1).has("name", "中铁十局集团有限公司").out("ComSec");
    
                Map map = new LinkedHashMap();
                map.put("name", "中铁十局集团有限公司");
                map.put("group", 1);
                map.put("index", nodes.size());
                nodes.add(map);
    
                int count = 0;
                while (mF.hasNext()) {
                    Vertex v1 = mF.next();
                    String section = g.V(v1).next().value("sectionname");
    
                    Map map1 = new LinkedHashMap();
                    map1.put("name", section);
                    map1.put("group", 2);
                    map1.put("index", nodes.size());
                    nodes.add(map1);
    
                    Map link1 = new LinkedHashMap();
                    link1.put("source", 0);
                    link1.put("target", nodes.size() - 1);
                    links.add(link1);
                    count = nodes.size() - 1;
    
                    Vertex v2 = g.V(v1).out("SecPro").next();
                    String project = g.V(v2).next().value("projectname");
    
                    int temp = 0;
                    int kk = 0;
                    for (Map m : nodes) {
                        if (m.containsValue(project)) {
                            kk = (int) m.get("index");
                            temp = 1;
                            break;
                        }
                    }
                    if (temp == 1) {
                        Map templink = new LinkedHashMap();
                        templink.put("source", nodes.size() - 1);
                        templink.put("target", kk);
                        links.add(templink);
                    } else {
                        Map map2 = new LinkedHashMap();
                        map2.put("name", project);
                        map2.put("group", 3);
                        map2.put("index", nodes.size());
                        nodes.add(map2);
    
                        Map link2 = new LinkedHashMap();
                        link2.put("source", count);
                        link2.put("target", nodes.size() - 1);
                        links.add(link2);
                    }
    
                }
    
    
                params.put("nodes", nodes);
                params.put("links", links);
                String jstr = gson.toJson(params);
                System.out.println(jstr);
                graph.close();
                return jstr;
    
            } catch (Exception e) {
                e.toString();
                return null;
            }
        }
    
          public static void main(String[] args) {
            TitanSearchByCompany search = new TitanSearchByCompany();
            String result = search.searchBycom();
        }    
    }

    成果展示

    由于Titan数据库没有可视化界面,所以我们在web平台上开发了根据搜索内容,呈现关系图谱的功能,图的展示主要用了D3中的力导向图,力导向图的实现将在下一篇文中由前端同事介绍。

    通过下面的搜索界面,得到公司或者项目的业绩图谱。
    这里写图片描述
    搜索“中铁十局集团有限公司”得到的关系图为:(效果图是不是很炫)
    这里写图片描述

    搜索项目“雅安至康定”得到下面的关系图谱,由于屏幕有限,只展示一层的关系。
    这里写图片描述

    文章到此结束,这是小编学了Titan数据库后完成的第一个项目,如有不对的地方,请在下方留言指正。感兴趣的我们可以相互交流。

    展开全文
  • Titan图数据库结构概述

    千次阅读 2018-09-29 11:30:27
    titan是一个图形数据库引擎。titan本身专注于紧凑的图形序列化、丰富的图形数据建模和高效的查询执行。此外,titan利用Hadoop进行图形分析和批处理处理。titan为数据持久性、数据索引和客户端访问实现健壮的、模块...

    结构概述

    titan是一个图形数据库引擎。titan本身专注于紧凑的图形序列化、丰富的图形数据建模和高效的查询执行。此外,titan利用Hadoop进行图形分析和批处理图处理。titan为数据持久性、数据索引和客户端访问实现健壮的、模块化的接口。titan的模块化架构使其能够与广泛的存储、索引和客户端技术进行互操作;它还简化了扩展titan的过程,以支持新的titan。

    在titan和磁盘之间有一个或多个存储和索引适配器。titan的标准有以下适配器,但是titan的模块化架构支持第三方适配器。
    数据存储

    Cassandra
    HBase
    BerkeleyDB

    索引,加速和启用更复杂的查询

    Elasticsearch’
    Lucene

    广泛地说,应用程序可以通过两种方式与泰坦进行交互:

    1. 方法调用Titan的Java API,其中包括

    泰坦的原生蓝图API实现
    一套名为Titan图的蓝图功能,它提供了一些Titan的特性,而这些特性并不是独立于供应商的蓝图规范的一部分。

    1. 在蓝图上构建的TinkerPop堆栈实用程序,例如

    Gremlin查询语言
    Rexster图服务器

    图2.1。高层Titan架构和环境
    在这里插入图片描述

    引用TItan官方文档:http://s3.thinkaurelius.com/docs/titan/0.5.0/arch-overview.html

    展开全文
  • Titan是一个分布式的图数据库,支持横向扩展,可容纳数千亿个节点和边。 Titan支持事务,并且可以支撑上千用户并发进行复杂图遍历操作。在这里使用Hbase存储数据,elasticsearch做索引。 Titan包含下面这些特性: ...

    Titan是一个分布式的图数据库,支持横向扩展,可容纳数千亿个节点和边。 Titan支持事务,并且可以支撑上千用户并发进行复杂图遍历操作。在这里使用Hbase存储数据,elasticsearch做索引。

    Titan包含下面这些特性:

    • 弹性与线性扩展

    • 分布式架构,可容错

    • 支持多数据中心的高可用和热备

    • 支持ACID和最终一致性

    • 支持多种存储后端

    1. Apache Cassandra

    2. Apache HBase

    3. Oracle BerkeleyDB

    4. Akiban Persistit

    • 支持位置、数字和全文检索

    1. ElasticSearch

    2. Apache Lucene

    • 原生支持TinkerPop软件栈

    1. Gremlin graph query language

    2. Frames object-to-graph mapper

    3. Rexster graph server

    4. Blueprints standard graph API

    • 开源协议 Apache 2 license
       

    一丶依赖环境

    JDK1.8jdk1.8.0_11这个版本有坑下载地址

    Ubuntu  下载地址

    titan-1.0.0-hadoop2 下载地址

    hadoop-2.7.1  下载地址

    hbase-0.98.12-hadoop2 下载地址

    elasticsearch-1.5.1请在titan-1.0.0-hadoop2/lib下寻找es对应版本进行下载下载地址

    二丶Hadoop安装(伪分布式)

    1. tar –xzvf  hadoop-2.7.1.tar.gz,解压到当前目录
    2. cd hadoop-2.7.1/etc/hadoop/目录下
    3. 配置core-site.xml
    <configuration>
            <!-- Hadoop 伪分布式配置 -->
    
            <!-- 使用 hadoop-2.5.2/tmp 做为 hdfs 的存储目录,默认为 /tmp
            <property>
                    <name>hadoop.tmp.dir</name>
                    <value>file:/tan/hadoop-2.7.1/tmp</value>
            </property>
    
            <property>
                    <name>fs.defaultFS</name>
                    <value>hdfs://localhost:9009</value>
            </property>
    </configuration>

     

    4. 配置hdfs-site.xml

    <configuration>
            <property>
                    <name>dfs.replication</name>
                    <value>1</value>
            </property>
    
            <property>
                    <name>dfs.namenode.name.dir</name>
                    <value>file:/tan/hadoop-2.7.1/tmp/dfs/name</value>
            </property>
    
            <property>
                    <name>dfs.datanode.data.dir</name>
                    <value>file:/tan/hadoop-2.7.1/tmp/dfs/name</value>
            </property>
    </configuration>

     

     

    5. 配置hadoop-env.sh,将JAVA_HOME改为JDK安装目录

    export JAVA_HOME=/tan/jdk1.8.0_172

     

    6. 启动hadoop服务。sbin/start-dfs.sh。启动成功后,执行jps,可以看到三个服务 NameNode、DataNode和SecondaryNameNode。成功启动后,可以访问 Web 界面 http://192.168.1.96:50070  来查看 Hadoop 的信息(在win系统上访问记得配置hosts

    三丶Hbase(单机模式)

    1.  tar –xzvf hbase-0.98.12-hadoop2-bin.tar.gz,解压到当前目录
    2.  cd  hbase-0.98.12-hadoop2/conf目录下
    3. 配置hbase-env.sh。如要使用外接zookeeper搭建伪分布式请参考:https://www.cnblogs.com/abc-begin/p/8206835.html

    4. 配置hbase-site.sh

    <configuration>
            <property>
                    <name>hbase.tmp.dir</name>
                    <value>/var/hbase</value>
            </property>
            <property>
                    <name>hbase.rootdir</name>
                    <value>hdfs://192.168.1.96:9000/hbase</value>
            </property>
            <property>
                    <name>hbase.cluster.distributed</name>
                    <value>true</value>
            </property>
            <property>
                    <name>hbase.zookeeper.quorum</name>
                    <value>Ubuntu-Zookeeper-Integrate-Quality</value>
            </property>
           <property>
                    <name>hbase.zookeeper.property.dataDir</name>
                    <value>/home/zkdata</value>
            </property>
    
            <property>
                    <name>hbase.master.info.port</name>
                    <value>60010</value>
            </property>
    </configuration>

    5. 启动Hbase。bin/start-hbase.sh完成

    四丶elasticsearch安装

    1. tar –xzvf  elasticsearch-1.5.1.tar.gz,解压到当前目录
    2. 启动elasticsearch。./bin/elasticsearch #看到如下输出,安装成功。服务最好使用nouhp在后台运行

    五丶Titan安装

    1. 解压unzip titan-1.0.0-hadoop2.zip
    2. 删除并添加相关jar包 。官方提供的hadoop2的安装包有一些问题,如果想要顺利的使用titan,必须删除相关的jar包,并添加一些缺失的jar包

    (a) 删除异常jar包

    hadoop-core-1.2.1.jar

    (b)添加所需要的jar包,这些jar包

    titan-hadoop-1.0.0.jar
    
    titan-hadoop-core-1.0.0.jar

    3.使用Gremlin客户端测试服务是否启动成功。./bin/gremlin.sh    #启动gremlin控制台,出来如下图表示成功

    六丶环境变量

    查看jps:

    展开全文
  • https://stackoverflow.com/questions/33719843/gremlin-from-titan-1-0-0-is-not-running-out-of-the-box-on-windows 解决方案如上 原答案: Found a solution in this google group for this...

    https://stackoverflow.com/questions/33719843/gremlin-from-titan-1-0-0-is-not-running-out-of-the-box-on-windows


    解决方案如上


    原答案:


    Found a solution in this google group for this issue and more:

    to run gremlin edit the gremlin.bat file:

    Change:

    set LIBDIR=..\lib
    

    To:

    set LIBDIR=lib
    

    Change:

    if "%CP%" == "" (
    set CP=%LIBDIR%\%1
    )else (
    set CP=%CP%;%LIBDIR%\%1
    )
    

    To:

    if "%CP%" == "" (
    set CP=%1
    )else (
    set CP=%CP%;%1
    )
    

    also, to add command history abilities to the gremlin command line:

    in the gremlin.bat file add to the set JAVA_OPTIONS line (solution from same source):

    set JAVA_OPTIONS=-Xms32m -Xmx512m -javaagent:%LIBDIR%\jamm-0.3.0.jar
    

    add:

    set JAVA_OPTIONS=-Xms32m -Xmx512m -javaagent:%LIBDIR%\jamm-0.3.0.jar -Djline.terminal=none
    

    and lastly, to change the loglevel: add a file named logback.xml in the titan-1.0.0-hadoop1 folder containing: (solution from the same source)

    <configuration>
      <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <!-- encoders are assigned the type
             ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
        <encoder>
          <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
      </appender>
      <root level="WARN"> <!-- set loglevel here-->
        <appender-ref ref="STDOUT" />
      </root>
    </configuration>

    展开全文
  • 传统的关系型数据库通过实体和关系来建模,在过去的很长一段时间内都占据着绝对的统治地位。但是随着大数据的兴起,它的一些缺陷也变得越来越明显,特别是在需要处理非常复杂的实体关系时,关系型数据库变得越来越...
  • Titan 是一个在服务器集群搭建的分布式的图形数据库,特别为存储和处理大规模图形而优化。集群很容易扩展以支持更大的数据集,Titan有一个很好的插件式性能,这个性能让它搭建在一些成熟的数据库技术... 标签:图数据库
  • !http://thinkaurelius.github.io/titan/images/titan-logo.png!
  • Titan数据库快速入门之决战云巅

    千次阅读 2017-11-03 19:36:21
    ...因公司业务发展,需要建立完整的关系图谱检索系统。经各种比较与考量,我们采用Titan图形数据库来处理复杂的...上一篇《Titan数据库快速入门之神的光芒》同事已经详细介绍了Titan数据库的安装与使用,这里不再
  • Java操作图数据库Titan

    千次阅读 2016-05-13 15:33:41
    大数据 05月 19, 2015 阅读(2,844) 评论(0) ...Titan 是一个分布式的图形数据库,特别为存储和处理大规模图形而优化。 支持不同的分布式存储层 Cassandra 1.1HBase 0.92 内置实现 Blueprints graph APIGremli
  • 图数据库 Titan 快速入门

    万次阅读 2014-10-01 21:38:44
    尤其在互联网世界,图计算越来越受到人们的关注,而图计算相关的软件也越来越丰富。本文将快速展示 Titan这个open source 的图数据库
  • 图数据库titan 和 rexster安装手册

    千次阅读 2016-05-13 15:52:36
    图数据库titan 和 rexster安装手册 titan图数据库, rexster是图显示服务 titan 安装 下载 titan 0.3.2 解压 titan-all-0.3.2.zip 到 /opt/hugedata/share/ 解压后得到 /opt/hugedata/share/titan-all-0.3.2/ ...
  • 本文将高速展示 Titan这个open source 的图数据库。 注:本文的操作主要基于Titan 官方的两篇文档: - http://s3.thinkaurelius.com/docs/titan/0.5.0/arch-overview.html - http://s3.thinkaurelius.co...
  • 图数据库Titan安装与部署

    千次阅读 2018-07-16 17:52:36
    Titan是一个分布式的图数据库,支持横向扩展,可容纳数千亿个节点和边。 Titan支持事务,并且可以支撑上千用户并发进行复杂图遍历操作。 Titan包含下面这些特性: 弹性与线性扩展 分布式架构,可容错 支持多数据...
  • Titan并不是数据库;它是一个数据库之上的客户端库。它依赖于下面的存储引擎,比如Cassandra或者Hadoop,来存储其数据。它也依赖于索引引擎,比如Lucene、ElasticSearch或者Solr,来执行相关的查询。   Titan 是...
  • 历史背景JanusGraph图数据库,源自于TitanDB开源图数据库。TitanDB在2012年发布第一个版本,2015年被Datastax公司收购,后续不再维护导致项目停滞。图数据库有2个最具代表性的查询语言:Cypher 及 Gremlin。Cypher是...
  • 图数据库Titan的使用总结

    千次阅读 2017-08-05 17:46:26
    1.搭建环境(hbase+es+titan1hadoop1为例) 下载安装 下载安装titan-1.0-hadoop1http://s3.thinkaurelius.com/downloads/titan/titan-1.0.0-hadoop1.zip 下载安装最新JDK...
  • 有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特功能...
  • 我有1亿的顶点和几十亿的边,如何通过BLVP加载到Titan 中,我后端的存储平台用的是Hbase。
  • 本文先简单介绍了图数据库的发展趋势,而后重点介绍了分布式图数据库Titan,围绕图数据库的典型查询(扩线查询)场景,分析了Titan在设计上的一些待改进点。从DB-Engines统计信息来看图数据库发展趋势从DB-Engines的...
  • Titan数据库简介

    千次阅读 2017-11-02 16:42:11
    from: http://s3.thinkaurelius.com/docs/titan/1.0.0/benefits.html...对于实时遍历和分析查询的缩放数据处理是泰坦的基础,对实时遍历和分析查询的弹性数据处理是Titan的基本优势。本节将讨论Titan的各种具体好处
  • TitanDB/JanusGraph图数据库入门简介|实战总结|选型对比|存储结构深入分析历史背景JanusGraph图数据库,源自于TitanDB开源图数据库。TitanDB在2012年发布第一个版本,2015年被Datastax公司收购,后续不再维护导致...
  • TitanDB/JanusGraph图数据库入门简介|实战总结|选型对比|存储结构深入分析历史背景JanusGraph图数据库,源自于TitanDB开源图数据库。TitanDB在2012年发布第一个版本,2015年被Datastax公司收购,后续不再维护导致...
  • 图数据库Titan/Gremlin查询过程分析

    千次阅读 2015-01-12 09:45:24
    本文对Titan/Gremlin的查询过程进行分析,为了简化明了,直接使用例子说明。 查询g.v(1).out.has(name, "David"),当前titan的做法是:  v(1)把v1的id找出来,返回该id --> out从上一步结果集合中,拉出一个,...
  • 图数据库Titan在生产环境中的使用全过程+分析 注:本文以Hbase作为backend,并以下图为例 vcD4KPGgxPjChosr9vt3Eo9DNPC9oMT4KPHA+VGl0YW7U2khiYXNl1tC1xLTmtKK94bm5PC9wPgo8dGFibGUgYm9yZGVyPQ=="1" ...
  • 图数据库Titan(Gremlin)对索引的创建

    千次阅读 2015-01-04 10:19:12
    对点上的属性创建索引,注意:We can retrieve it from the index using the getVertices(String,...TitanGraph g = TitanFactory.open("/tmp/titan");  g.createKeyIndex("name",Vertex.class);  Vertex juno

空空如也

空空如也

1 2 3 4 5
收藏数 100
精华内容 40
关键字:

titan图数据库