Example usage for org.apache.lucene.index IndexWriterConfig setOpenMode

List of usage examples for org.apache.lucene.index IndexWriterConfig setOpenMode

Introduction

In this page you can find the example usage for org.apache.lucene.index IndexWriterConfig setOpenMode.

Prototype

public IndexWriterConfig setOpenMode(OpenMode openMode) 

Source Link

Document

Specifies OpenMode of the index.

Usage

From source file:com.mycompany.restlet.search.sample.indexer.java

License:Apache License

/** Index all text files under a directory. */
public static void main(String[] args) {
    String usage = "java org.apache.lucene.demo.IndexFiles"
            + " [-index INDEX_PATH] [-docs DOCS_PATH] [-update]\n\n"
            + "This indexes the documents in DOCS_PATH, creating a Lucene index"
            + "in INDEX_PATH that can be searched with SearchFiles";
    String indexPath = "index";
    String docsPath = null;//from  w  w  w . j a v a 2 s. c  o  m
    boolean create = true;
    for (int i = 0; i < args.length; i++) {
        if ("-index".equals(args[i])) {
            indexPath = args[i + 1];
            i++;
        } else if ("-docs".equals(args[i])) {
            docsPath = args[i + 1];
            i++;
        } else if ("-update".equals(args[i])) {
            create = false;
        }
    }

    if (docsPath == null) {
        System.err.println("Usage: " + usage);
        System.exit(1);
    }

    final Path docDir = Paths.get(docsPath);
    if (!Files.isReadable(docDir)) {
        System.out.println("Document directory '" + docDir.toAbsolutePath()
                + "' does not exist or is not readable, please check the path");
        System.exit(1);
    }

    Date start = new Date();
    try {
        System.out.println("Indexing to directory '" + indexPath + "'...");

        Directory dir = FSDirectory.open(Paths.get(indexPath));
        Analyzer analyzer = new StandardAnalyzer();
        //         MorphemeAnalyzer ma = new MorphemeAnalyzer();

        IndexWriterConfig iwc = new IndexWriterConfig(analyzer);

        if (create) {
            // Create a new index in the directory, removing any
            // previously indexed documents:
            iwc.setOpenMode(OpenMode.CREATE);
        } else {
            // Add new documents to an existing index:
            iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
        }

        // Optional: for better indexing performance, if you
        // are indexing many documents, increase the RAM
        // buffer.  But if you do this, increase the max heap
        // size to the JVM (eg add -Xmx512m or -Xmx1g):
        //
        // iwc.setRAMBufferSizeMB(256.0);

        IndexWriter writer = new IndexWriter(dir, iwc);
        indexDocs(writer, docDir);

        // NOTE: if you want to maximize search performance,
        // you can optionally call forceMerge here.  This can be
        // a terribly costly operation, so generally it's only
        // worth it when your index is relatively static (ie
        // you're done adding documents to it):
        //
        // writer.forceMerge(1);
        writer.close();

        Date end = new Date();
        System.out.println(end.getTime() - start.getTime() + " total milliseconds");

    } catch (IOException e) {
        System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());
    }
}

From source file:com.mylucene.basiclucene.IndexFiles.java

License:Apache License

/** Index all text files under a directory. */
public static void main(String[] args) {
    String usage = "java org.apache.lucene.demo.IndexFiles"
            + " [-index INDEX_PATH] [-docs DOCS_PATH] [-update]\n\n"
            + "This indexes the documents in DOCS_PATH, creating a Lucene index"
            + "in INDEX_PATH that can be searched with SearchFiles";
    String indexPath = "index";
    String docsPath = null;/*from w w  w  .  ja v a2 s  .  co  m*/
    boolean create = true;
    for (int i = 0; i < args.length; i++) {
        if ("-index".equals(args[i])) {
            indexPath = args[i + 1];
            i++;
        } else if ("-docs".equals(args[i])) {
            docsPath = args[i + 1];
            i++;
        } else if ("-update".equals(args[i])) {
            create = false;
        }
    }

    if (docsPath == null) {
        System.err.println("Usage: " + usage);
        System.exit(1);
    }

    final File docDir = new File(docsPath);
    if (!docDir.exists() || !docDir.canRead()) {
        System.out.println("Document directory '" + docDir.getAbsolutePath()
                + "' does not exist or is not readable, please check the path");
        System.exit(1);
    }

    Date start = new Date();
    try {
        System.out.println("Indexing to directory '" + indexPath + "'...");

        Directory dir = FSDirectory.open(new File(indexPath));
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_44);
        IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_44, analyzer);

        if (create) {
            // Create a new index in the directory, removing any
            // previously indexed documents:
            iwc.setOpenMode(OpenMode.CREATE);
        } else {
            // Add new documents to an existing index:
            iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
        }

        // Optional: for better indexing performance, if you
        // are indexing many documents, increase the RAM
        // buffer.  But if you do this, increase the max heap
        // size to the JVM (eg add -Xmx512m or -Xmx1g):
        //
        // iwc.setRAMBufferSizeMB(256.0);

        IndexWriter writer = new IndexWriter(dir, iwc);
        indexDocs(writer, docDir);

        // NOTE: if you want to maximize search performance,
        // you can optionally call forceMerge here.  This can be
        // a terribly costly operation, so generally it's only
        // worth it when your index is relatively static (ie
        // you're done adding documents to it):
        //
        // writer.forceMerge(1);

        writer.close();

        Date end = new Date();
        System.out.println(end.getTime() - start.getTime() + " total milliseconds");

    } catch (IOException e) {
        System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());
    }
}

From source file:com.nero.model.IndexFiles.java

License:Apache License

/** Index all text files under a directory. */
public static void main(String[] args) {
    String usage = "java org.apache.lucene.demo.IndexFiles"
            + " [-index INDEX_PATH] [-docs DOCS_PATH] [-update]\n\n"
            + "This indexes the documents in DOCS_PATH, creating a Lucene index"
            + "in INDEX_PATH that can be searched with SearchFiles";
    String indexPath = "index";
    String docsPath = "docspath";
    boolean create = true;
    //    for(int i=0;i<args.length;i++) {
    //      if ("-index".equals(args[i])) {
    //        indexPath = args[i+1];
    //        i++;
    //      } else if ("-docs".equals(args[i])) {
    //        docsPath = args[i+1];
    //        i++;
    //      } else if ("-update".equals(args[i])) {
    //        create = false;
    //      }//from  www.  ja  va  2  s  .  co  m
    //    }

    if (docsPath == null) {
        System.err.println("Usage: " + usage);
        System.exit(1);
    }

    final File docDir = new File(docsPath);
    if (!docDir.exists() || !docDir.canRead()) {
        System.out.println("Document directory '" + docDir.getAbsolutePath()
                + "' does not exist or is not readable, please check the path");
        System.exit(1);
    }

    Date start = new Date();
    try {
        System.out.println("Indexing to directory '" + indexPath + "'...");

        Directory dir = FSDirectory.open(new File(indexPath));
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_31);
        IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_31, analyzer);

        if (create) {
            // Create a new index in the directory, removing any
            // previously indexed documents:
            iwc.setOpenMode(OpenMode.CREATE);
        } else {
            // Add new documents to an existing index:
            iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
        }

        // Optional: for better indexing performance, if you
        // are indexing many documents, increase the RAM
        // buffer.  But if you do this, increase the max heap
        // size to the JVM (eg add -Xmx512m or -Xmx1g):
        //
        // iwc.setRAMBufferSizeMB(256.0);

        IndexWriter writer = new IndexWriter(dir, iwc);
        indexDocs(writer, docDir);

        // NOTE: if you want to maximize search performance,
        // you can optionally call forceMerge here.  This can be
        // a terribly costly operation, so generally it's only
        // worth it when your index is relatively static (ie
        // you're done adding documents to it):
        //
        // writer.forceMerge(1);

        writer.close();

        Date end = new Date();
        System.out.println(end.getTime() - start.getTime() + " total milliseconds");

    } catch (IOException e) {
        System.out.println(" caught a " + e.getClass() + "\n with message: " + e.getMessage());
    }
}

From source file:com.netcrest.pado.index.gemfire.lucene.TemporalLuceneDynamicIndexing.java

License:Open Source License

/**
 * Resets the writer that writes to the file system.
 *//*from   ww  w  .jav  a2s. c o  m*/
private void resetWriter() {
    close();

    File file = new File("lucene" + fullPath);
    if (file.exists() == false) {
        file.mkdirs();
    }
    Analyzer analyzer = new StandardAnalyzer(LuceneSearch.LUCENE_VERSION);
    IndexWriterConfig iwc = new IndexWriterConfig(LuceneSearch.LUCENE_VERSION, analyzer);
    iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
    try {
        MMapDirectory directory = new MMapDirectory(file);
        writer = new IndexWriter(directory, iwc);
        luceneSearch = LuceneSearch.getLuceneSearch(fullPath);
        parser = luceneSearch.createParser();
        isClosed = false;
    } catch (IOException e) {
        Logger.error(e);
    }
}

From source file:com.netcrest.pado.index.provider.lucene.LuceneBuilderRAMDirectory.java

License:Open Source License

@SuppressWarnings({ "unchecked", "rawtypes", "resource" })
public void buildTemporalKeys(boolean createNewDirectory) {
    Cache cache = CacheFactory.getAnyInstance();
    Region<String, RAMDirectory> region = cache
            .getRegion(IndexMatrixUtil.getProperty(Constants.PROP_REGION_LUCENE));
    TemporalType[] temporalTypes = GemfireTemporalManager.getAllTemporalTypes();

    for (TemporalType type : temporalTypes) {
        IndexWriter writer = null;/*  ww w  .  j a va 2s .  co m*/
        Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_47);
        IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_47, analyzer);
        iwc.setOpenMode(OpenMode.CREATE);
        LuceneField luceneBuilder = new LuceneField();

        LuceneSearch ls = LuceneSearch.getLuceneSearch(type.getFullPath());
        StandardQueryParser parser = ls.createParser();
        TemporalManager tm = TemporalManager.getTemporalManager(type.getFullPath());
        try {
            List<?> identityKeyList = tm.getIdentityKeyList();
            if (identityKeyList.size() == 0) {
                continue;
            }

            RAMDirectory directory;
            if (createNewDirectory) {
                directory = new RAMDirectory();
            } else {
                directory = region.get(type.getFullPath());
                if (directory == null) {
                    directory = new RAMDirectory();
                }
            }
            writer = new IndexWriter(directory, iwc);

            // determine the identity key type, public fields and getters
            Field fields[] = null;
            Method getters[] = null;
            Class keyType = null;
            for (Object key : identityKeyList) {
                if (ReflectionHelper.isPrimitiveWrapper(key.getClass())) {
                    fields = null;
                    getters = null;
                    keyType = key.getClass();
                } else {
                    fields = ReflectionHelper.getPublicFields(key.getClass());
                    getters = ReflectionHelper.getPublicGetters(key.getClass());
                }
                break;
            }

            if (keyType != null) {

                configNumericType(parser, "IdentityKey", keyType);

                // primitive
                List<Document> docList = new ArrayList();
                if (keyType == String.class) {
                    for (Object key : identityKeyList) {
                        // TODO: do lucene here
                        Document doc = luceneBuilder.createDocument();
                        doc.add(luceneBuilder.createField("IdentityKey", key.toString()));
                        docList.add(doc);
                    }
                } else if (keyType == Integer.class) {
                    for (Object key : identityKeyList) {
                        // TODO: do lucene here
                        Document doc = luceneBuilder.createDocument();
                        doc.add(luceneBuilder.createField("IdentityKey", (Integer) key));
                        docList.add(doc);
                    }
                } else if (keyType == Long.class) {
                    for (Object key : identityKeyList) {
                        // TODO: do lucene here
                        Document doc = luceneBuilder.createDocument();
                        doc.add(luceneBuilder.createField("IdentityKey", (Long) key));
                        docList.add(doc);
                    }
                } else if (keyType == Float.class) {
                    for (Object key : identityKeyList) {
                        // TODO: do lucene here
                        Document doc = luceneBuilder.createDocument();
                        doc.add(luceneBuilder.createField("IdentityKey", (Float) key));
                        docList.add(doc);
                    }
                } else if (keyType == Double.class) {
                    for (Object key : identityKeyList) {
                        // TODO: do lucene here
                        Document doc = luceneBuilder.createDocument();
                        doc.add(luceneBuilder.createField("IdentityKey", (Double) key));
                        docList.add(doc);
                    }
                }
                try {
                    writer.addDocuments(docList);
                } catch (Exception ex) {
                    Logger.warning(ex);
                }
            } else {
                try {
                    // fields
                    if (fields != null && fields.length > 0) {

                        // configure numeric types
                        for (Field field : fields) {
                            configNumericType(parser, field.getName(), field.getType());
                        }

                        List<Document> docList = new ArrayList();
                        for (Object key : identityKeyList) {
                            Document doc = luceneBuilder.createDocument();
                            for (Field field : fields) {
                                Object obj = field.get(key);
                                Class fieldType = field.getType();
                                if (fieldType == String.class) {
                                    doc.add(luceneBuilder.createField(field.getName(), obj.toString()));
                                } else if (fieldType == Integer.class || fieldType == int.class) {
                                    doc.add(luceneBuilder.createField(field.getName(), (Integer) obj));
                                } else if (fieldType == Long.class || fieldType == long.class) {
                                    doc.add(luceneBuilder.createField(field.getName(), (Long) obj));
                                } else if (fieldType == Float.class || fieldType == float.class) {
                                    doc.add(luceneBuilder.createField(field.getName(), (Float) obj));
                                } else if (fieldType == Double.class || fieldType == double.class) {
                                    doc.add(luceneBuilder.createField(field.getName(), (Double) obj));
                                } else if (fieldType == Date.class) {
                                    doc.add(luceneBuilder.createField(field.getName(), ((Date) obj).getTime()));
                                }
                            }
                            docList.add(doc);
                        }
                        try {
                            writer.addDocuments(docList);
                        } catch (Exception ex) {
                            Logger.warning(ex);
                        }
                    }

                    // getters - methods
                    if (getters != null && getters.length > 0) {
                        List<Document> docList = new ArrayList();
                        for (Object key : identityKeyList) {
                            Document doc = luceneBuilder.createDocument();
                            for (Method method : getters) {
                                // TODO: build lucene here
                                Object obj = method.invoke(key);
                                Class<?> fieldType = method.getReturnType();
                                if (fieldType == String.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), obj.toString()));
                                } else if (fieldType == Integer.class || fieldType == int.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Integer) obj));
                                } else if (fieldType == Long.class || fieldType == long.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Long) obj));
                                } else if (fieldType == Float.class || fieldType == float.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Float) obj));
                                } else if (fieldType == Double.class || fieldType == double.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Double) obj));
                                } else if (fieldType == Date.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method),
                                            ((Date) obj).getTime()));
                                }
                            }
                            docList.add(doc);
                        }
                        try {
                            writer.addDocuments(docList);
                        } catch (Exception ex) {
                            Logger.warning(ex);
                        }
                    }

                } catch (Exception ex) {
                    Logger.warning(ex);
                }
            }

            writer.commit();
            writer.close();

            // TODO: support file system
            // place the RamDirectory in lucene
            region.put(type.getFullPath(), directory);

        } catch (Exception ex) {
            Logger.error("Index builder aborted.", ex);
            return;
        }
    }
}

From source file:com.netcrest.pado.index.provider.lucene.LuceneBuilderRAMDirectory.java

License:Open Source License

@SuppressWarnings({ "rawtypes", "resource" })
public void buildTemporalData(boolean createNewDirectory) {
    Cache cache = CacheFactory.getAnyInstance();
    Region<String, RAMDirectory> region = cache
            .getRegion(IndexMatrixUtil.getProperty(Constants.PROP_REGION_LUCENE));

    try {//from w w  w  .  ja  v  a2  s.  c  o m
        TemporalType[] temporalTypes = GemfireTemporalManager.getAllTemporalTypes();
        for (TemporalType type : temporalTypes) {
            IndexWriter writer = null;
            Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_47);
            IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_47, analyzer);
            iwc.setOpenMode(OpenMode.CREATE);
            LuceneField luceneBuilder = new LuceneField();

            LuceneSearch ls = LuceneSearch.getLuceneSearch(type.getFullPath());
            StandardQueryParser parser = ls.createParser();
            TemporalManager tm = TemporalManager.getTemporalManager(type.getFullPath());
            Method[] attributeGetters = null;
            boolean isIdentityKeyPrimitive = false;
            try {
                List identityKeyList = tm.getIdentityKeyList();
                if (identityKeyList.size() == 0) {
                    continue;
                }

                RAMDirectory directory;
                if (createNewDirectory) {
                    directory = new RAMDirectory();
                } else {
                    directory = region.get(type.getFullPath());
                    if (directory == null) {
                        directory = new RAMDirectory();
                    }
                }
                writer = new IndexWriter(directory, iwc);

                // first, find the attribute getter methods
                boolean isKeyMap = false;
                KeyType keyType = null;
                for (Object identityKey : identityKeyList) {
                    TemporalEntry entry = tm.getLastEntry(identityKey);
                    ITemporalData data = entry.getTemporalData();
                    Object value;
                    if (data instanceof GemfireTemporalData) {
                        value = ((GemfireTemporalData) data).getValue();
                    } else {
                        value = data;
                    }
                    isKeyMap = value instanceof KeyMap;
                    if (isKeyMap == false) {
                        attributeGetters = ReflectionHelper.getAttributeGetters(data.getClass());
                    } else {
                        keyType = ((KeyMap) value).getKeyType();

                    }
                    isIdentityKeyPrimitive = ReflectionHelper.isPrimitiveWrapper(identityKey.getClass());
                    break;
                }

                // build the numeric config
                Map<String, NumericConfig> map = parser.getNumericConfigMap();
                if (map == null) {
                    map = new HashMap<String, NumericConfig>();
                    parser.setNumericConfigMap(map);
                }

                if (isKeyMap) {

                    KeyType[] keyTypes = KeyTypeManager.getAllRegisteredVersions(keyType.getClass());
                    for (KeyType kt : keyTypes) {
                        Set<String> nameSet = kt.getNameSet();
                        for (String name : nameSet) {
                            if (map.containsKey(name)) {
                                continue;
                            }
                            KeyType kt2 = kt.getKeyType(name);
                            String fieldName = kt2.getName();
                            Class<?> fieldType = kt2.getType();

                            if (fieldType == Integer.class || fieldType == int.class) {
                                NumericConfig config = new NumericConfig(PRECISION_STEP,
                                        NumberFormat.getNumberInstance(), NumericType.INT);
                                map.put(fieldName, config);
                            } else if (fieldType == Long.class || fieldType == long.class) {
                                NumericConfig config = new NumericConfig(PRECISION_STEP,
                                        NumberFormat.getNumberInstance(), NumericType.LONG);
                                map.put(fieldName, config);
                            } else if (fieldType == Float.class || fieldType == float.class) {
                                NumericConfig config = new NumericConfig(PRECISION_STEP,
                                        NumberFormat.getNumberInstance(), NumericType.FLOAT);
                                map.put(fieldName, config);
                            } else if (fieldType == Double.class || fieldType == double.class) {
                                NumericConfig config = new NumericConfig(PRECISION_STEP,
                                        NumberFormat.getNumberInstance(), NumericType.DOUBLE);
                                map.put(fieldName, config);
                            } else if (fieldType == Date.class) {
                                NumericConfig config = new NumericConfig(PRECISION_STEP, DATE_FORMAT,
                                        NumericType.LONG);
                                map.put(fieldName, config);
                            }
                        }
                    }

                    List<Document> docList = new ArrayList<Document>();

                    for (Object identityKey : identityKeyList) {
                        TemporalEntry entry = tm.getLastEntry(identityKey);
                        ITemporalData data = entry.getTemporalData();
                        KeyMap keyMap;
                        if (data instanceof GemfireTemporalData) {
                            keyMap = (KeyMap) ((GemfireTemporalData) data).getValue();
                        } else {
                            keyMap = (KeyMap) data;
                        }
                        keyType = keyMap.getKeyType();
                        Set<String> nameSet = keyType.getNameSet();

                        Document doc = luceneBuilder.createDocument();
                        if (isIdentityKeyPrimitive) {
                            doc.add(luceneBuilder.createField("IdentityKey", identityKey.toString()));
                        } else {
                            doc.add(luceneBuilder.createIdentityKeyField(identityKey));
                        }
                        for (String name : nameSet) {
                            Object obj = keyMap.get(name);
                            // obj can be null (e.g., version difference or
                            // app defined)
                            if (obj == null) {
                                continue;
                            }
                            KeyType kt = keyType.getKeyType(name);
                            Class fieldType = kt.getType();
                            if (fieldType == String.class) {
                                doc.add(luceneBuilder.createField(name, obj.toString()));
                            } else if (fieldType == Integer.class || fieldType == int.class) {
                                doc.add(luceneBuilder.createField(name, (Integer) obj));
                            } else if (fieldType == Long.class || fieldType == long.class) {
                                doc.add(luceneBuilder.createField(name, (Long) obj));
                            } else if (fieldType == Float.class || fieldType == float.class) {
                                doc.add(luceneBuilder.createField(name, (Float) obj));
                            } else if (fieldType == Double.class || fieldType == double.class) {
                                doc.add(luceneBuilder.createField(name, (Double) obj));
                            } else if (fieldType == Date.class) {
                                doc.add(luceneBuilder.createField(name, ((Date) obj).getTime()));
                            }
                        }
                        docList.add(doc);
                    }
                    try {
                        writer.addDocuments(docList);
                    } catch (Exception ex) {
                        Logger.warning("MapLite error", ex);
                    }

                } else {
                    for (Method method : attributeGetters) {
                        Class fieldType = method.getReturnType();
                        String fieldName = method.getName().substring(3);
                        if (fieldType == Integer.class || fieldType == int.class) {
                            NumericConfig config = new NumericConfig(PRECISION_STEP,
                                    NumberFormat.getNumberInstance(), NumericType.INT);
                            map.put(fieldName, config);
                        } else if (fieldType == Long.class || fieldType == long.class) {
                            NumericConfig config = new NumericConfig(PRECISION_STEP,
                                    NumberFormat.getNumberInstance(), NumericType.LONG);
                            map.put(fieldName, config);
                        } else if (fieldType == Float.class || fieldType == float.class) {
                            NumericConfig config = new NumericConfig(PRECISION_STEP,
                                    NumberFormat.getNumberInstance(), NumericType.FLOAT);
                            map.put(fieldName, config);
                        } else if (fieldType == Double.class || fieldType == double.class) {
                            NumericConfig config = new NumericConfig(PRECISION_STEP,
                                    NumberFormat.getNumberInstance(), NumericType.DOUBLE);
                            map.put(fieldName, config);
                        } else if (fieldType == Date.class) {
                            NumericConfig config = new NumericConfig(PRECISION_STEP, DATE_FORMAT,
                                    NumericType.LONG);
                            map.put(fieldName, config);
                        }
                    }

                    // build lucene for each attribute in the current
                    // (latest)
                    // data
                    if (attributeGetters != null && attributeGetters.length > 0) {
                        List<Document> docList = new ArrayList<Document>();

                        for (Object identityKey : identityKeyList) {
                            TemporalEntry entry = tm.getLastEntry(identityKey);
                            ITemporalData data = entry.getTemporalData();
                            Document doc = luceneBuilder.createDocument();
                            if (isIdentityKeyPrimitive) {
                                doc.add(luceneBuilder.createField("IdentityKey", identityKey.toString()));
                            } else {
                                doc.add(luceneBuilder.createIdentityKeyField(identityKey));
                            }
                            for (Method method : attributeGetters) {
                                Object obj = method.invoke(data);
                                Class fieldType = method.getReturnType();
                                if (fieldType == String.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), obj.toString()));
                                } else if (fieldType == Integer.class || fieldType == int.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Integer) obj));
                                } else if (fieldType == Long.class || fieldType == long.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Long) obj));
                                } else if (fieldType == Float.class || fieldType == float.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Float) obj));
                                } else if (fieldType == Double.class || fieldType == double.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method), (Double) obj));
                                } else if (fieldType == Date.class) {
                                    doc.add(luceneBuilder.createField(getPropertyName(method),
                                            ((Date) obj).getTime()));
                                }
                            }
                            docList.add(doc);
                        }
                        try {
                            writer.addDocuments(docList);
                        } catch (Exception ex) {
                            Logger.warning("Non-MapLite error", ex);
                        }
                    }
                }

                writer.commit();
                writer.close();

                // TODO: support file system
                // place the RamDirectory in the lucene
                region.put(type.getFullPath(), directory);

            } catch (Exception ex) {
                Logger.warning(ex);
            }
        }
    } catch (Exception ex) {
        Logger.warning("Index builder aborted.", ex);
    }
}

From source file:com.netcrest.pado.temporal.gemfire.impl.LuceneTemporalEntryBuilder.java

License:Open Source License

public LuceneTemporalEntryBuilder(String fullPath) {
    try {/*from   w  ww. j a  va2s.  com*/
        File file = new File("lucene" + fullPath);
        if (file.exists() == false) {
            file.mkdirs();
        }
        Analyzer analyzer = new StandardAnalyzer(LuceneSearch.LUCENE_VERSION);
        IndexWriterConfig iwc = new IndexWriterConfig(LuceneSearch.LUCENE_VERSION, analyzer);
        iwc.setOpenMode(OpenMode.CREATE);
        directory = new MMapDirectory(file);
        writer = new IndexWriter(directory, iwc);
        tm = TemporalManager.getTemporalManager(fullPath);
        writer.commit();
        parser = LuceneSearch.getLuceneSearch(fullPath).createParser();
        configNumericType("StartValidTime", Date.class);
        configNumericType("EndValidTime", Date.class);
        configNumericType("StartWrittenTime", Date.class);
        configNumericType("EndWrittenTime", Date.class);
    } catch (IOException ex) {
        Logger.error(ex);
    }
}

From source file:com.nokia.vikram.lire.LireIndexer.java

License:Open Source License

public static void indexImages(String inputFramesRootDir, String indexDirectory) {
    try {/*from  w  w w  . j  av  a  2  s.  c  om*/
        // Getting all images from a directory and its sub directories.
        ArrayList<String> images = FileUtils.getAllImages(new File(inputFramesRootDir), true);

        // Creating a CEDD document builder and indexing all files.
        DocumentBuilder builder = DocumentBuilderFactory.getCEDDDocumentBuilder();

        // Creating an Lucene IndexWriter
        IndexWriterConfig conf = new IndexWriterConfig(LuceneUtils.LUCENE_VERSION,
                new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
        conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

        IndexWriter iw = new IndexWriter(FSDirectory.open(new File(indexDirectory)), conf);

        // Iterating through images building the low level features
        for (Iterator<String> it = images.iterator(); it.hasNext();) {
            String imageFilePath = it.next();
            System.out.println("Indexing image: " + imageFilePath);
            try {
                BufferedImage img = ImageIO.read(new FileInputStream(imageFilePath));
                Document document = builder.createDocument(img, imageFilePath);
                iw.addDocument(document);
            } catch (Exception e) {
                System.err.println("ERR: Could not read image or index it!");
                e.printStackTrace();
            }
        }

        // Close the IndexWriter
        iw.close();
        System.out.println("Indexing completed.");
    } catch (IOException e) {
        System.out.println("ERR: IOException while attempting to build index!");
        e.printStackTrace();
    }
}

From source file:com.orientechnologies.lucene.manager.OLuceneFullTextIndexManager.java

License:Apache License

@Override
public IndexWriter createIndexWriter(Directory directory, ODocument metadata) throws IOException {

    Analyzer analyzer = getAnalyzer(metadata);
    Version version = getLuceneVersion(metadata);
    IndexWriterConfig iwc = new IndexWriterConfig(version, analyzer);
    iwc.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

    facetManager = new OLuceneFacetManager(this, metadata);

    OLogManager.instance().debug(this, "Creating Lucene index in '%s'...", directory);

    return new IndexWriter(directory, iwc);
}

From source file:com.orientechnologies.lucene.manager.OLuceneFullTextIndexManager.java

License:Apache License

@Override
public IndexWriter openIndexWriter(Directory directory, ODocument metadata) throws IOException {
    Analyzer analyzer = getAnalyzer(metadata);
    Version version = getLuceneVersion(metadata);
    IndexWriterConfig iwc = new IndexWriterConfig(version, analyzer);
    iwc.setOpenMode(IndexWriterConfig.OpenMode.APPEND);

    OLogManager.instance().debug(this, "Opening Lucene index in '%s'...", directory);

    return new IndexWriter(directory, iwc);
}