content: /**
   * 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.
   */
  
  package org.apache.solr.update;
  
  
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Fieldable;
  import org.apache.lucene.search.Collector;
  import org.apache.lucene.search.Scorer;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import java.util.Vector;
  import java.io.IOException;
  
  import org.apache.solr.search.SolrIndexSearcher;
  import org.apache.solr.schema.IndexSchema;
  import org.apache.solr.schema.SchemaField;
  import org.apache.solr.schema.FieldType;
  import org.apache.solr.common.SolrException;
  import org.apache.solr.util.plugin.SolrCoreAware;
  import org.apache.solr.core.*;
  
  /**
   * <code>UpdateHandler</code> handles requests to change the index
   * (adds, deletes, commits, optimizes, etc).
   *
   * @version $Id: UpdateHandler.java 1100480 2011-05-07 08:37:00Z uschindler $
   * @since solr 0.9
   */
  
  public abstract class UpdateHandler implements SolrInfoMBean {
  	public static String UPDATEPARTION="higoupdate";
  	
    protected final static Logger log = LoggerFactory.getLogger(UpdateHandler.class);
  //
  //  protected final SolrCore core;
  //  protected final IndexSchema schema;
  //
  //  protected final SchemaField idField;
  //  protected final FieldType idFieldType;
  //  protected final Term idTerm; // prototype term to avoid interning fieldname
  //
  //  protected Vector<SolrEventListener> commitCallbacks = new Vector<SolrEventListener>();
  //  protected Vector<SolrEventListener> optimizeCallbacks = new Vector<SolrEventListener>();
  
  //  private void parseEventListeners() {
  //    final Class<SolrEventListener> clazz = SolrEventListener.class;
  //    final String label = "Event Listener";
  //    for (PluginInfo info : core.getSolrConfig().getPluginInfos(SolrEventListener.class.getName())) {
  //      String event = info.attributes.get("event");
  //      if ("postCommit".equals(event)) {
  //        SolrEventListener obj = core.createInitInstance(info,clazz,label,null);
  //        commitCallbacks.add(obj);
  //        log.info("added SolrEventListener for postCommit: " + obj);
  //      } else if ("postOptimize".equals(event)) {
  //        SolrEventListener obj = core.createInitInstance(info,clazz,label,null);
  //        optimizeCallbacks.add(obj);
  //        log.info("added SolrEventListener for postOptimize: " + obj);
  //      }
  //    }
  //  }
  //
  //  protected void callPostCommitCallbacks() {
  //    for (SolrEventListener listener : commitCallbacks) {
  //      listener.postCommit();
  //    }
  //  }
  //
  //  protected void callPostOptimizeCallbacks() {
  //    for (SolrEventListener listener : optimizeCallbacks) {
  //      listener.postCommit();
  //    }
  //  }
  
    public UpdateHandler(SolrCore core)  {
  //    this.core=core;
  //    schema = core.getSchema();
  //    idField = schema.getUniqueKeyField();
  //    idFieldType = idField!=null ? idField.getType() : null;
  //    idTerm = idField!=null ? new Term(idField.getName(),"") : null;
  //    parseEventListeners();
    }
  
  //  protected SolrIndexWriter createMainIndexWriter(String name, boolean removeAllExisting) throws IOException {
  //    return new SolrIndexWriter(name,core.getIndexDir(UpdateHandler.UPDATEPARTION), core.getDirectoryFactory(), removeAllExisting, schema, core.getSolrConfig().mainIndexConfig, core.getDeletionPolicy());
  //  }
  //
  //  protected final Term idTerm(String readableId) {
  //    // to correctly create the Term, the string needs to be run
  //    // through the Analyzer for that field.
  //    return new Term(idField.getName(), idFieldType.toInternal(readableId));
  //  }
  //
  //  protected final String getIndexedId(Document doc) {
  //    if (idField == null)
  //      throw new SolrException( SolrException.ErrorCode.BAD_REQUEST,"Operation requires schema to have a unique key field");
  //
  //    // Right now, single valued fields that require value transformation from external to internal (indexed)
  //    // form have that transformation already performed and stored as the field value.
  //    Fieldable[] id = doc.getFieldables( idField.getName() );
  //    if (id == null || id.length < 1)
  //      throw new SolrException( SolrException.ErrorCode.BAD_REQUEST,"Document is missing mandatory uniqueKey field: " + idField.getName());
  //    if( id.length > 1 )
  //      throw new SolrException( SolrException.ErrorCode.BAD_REQUEST,"Document contains multiple values for uniqueKey field: " + idField.getName());
  //
  //    return idFieldType.storedToIndexed( id[0] );
  //  }
  //
  //  protected final String getIndexedIdOptional(Document doc) {
  //    if (idField == null) return null;
  //    Fieldable f = doc.getFieldable(idField.getName());
  //    if (f == null) return null;
  //    return idFieldType.storedToIndexed(f);
  //  }
  
  
    public abstract int addDoc(AddUpdateCommand cmd) throws IOException;
    public abstract void delete(DeleteUpdateCommand cmd) throws IOException;
    public abstract void deleteByQuery(DeleteUpdateCommand cmd) throws IOException;
    public abstract int mergeIndexes(MergeIndexesCommand cmd) throws IOException;
    public abstract void commit(CommitUpdateCommand cmd) throws IOException;
    public abstract void rollback(RollbackUpdateCommand cmd) throws IOException;
    public abstract void close() throws IOException;
  
  
  //  static class DeleteHitCollector extends Collector {
  //    public int deleted=0;
  //    public final SolrIndexSearcher searcher;
  //    private int docBase;
  //
  //    public DeleteHitCollector(SolrIndexSearcher searcher) {
  //      this.searcher = searcher;
  //    }
  //
  //    @Override
  //    public void collect(int doc) {
  //      try {
  //        searcher.getReader().deleteDocument(doc + docBase);
  //        deleted++;
  //      } catch (IOException e) {
  //        // don't try to close the searcher on failure for now...
  //        // try { closeSearcher(); } catch (Exception ee) { SolrException.log(log,ee); }
  //        throw new SolrException( SolrException.ErrorCode.SERVER_ERROR,"Error deleting doc# "+doc,e,false);
  //      }
  //    }
  //
  //    @Override
  //    public boolean acceptsDocsOutOfOrder() {
  //      return false;
  //    }
  //
  //    @Override
  //    public void setNextReader(IndexReader arg0, int docBase) throws IOException {
  //      this.docBase = docBase;
  //    }
  //
  //    @Override
  //    public void setScorer(Scorer scorer) throws IOException {
  //      
  //    }
  //  }
  //
  //
  //  /**
  //   * NOTE: this function is not thread safe.  However, it is safe to call within the
  //   * <code>inform( SolrCore core )</code> function for <code>SolrCoreAware</code> classes.
  //   * Outside <code>inform</code>, this could potentially throw a ConcurrentModificationException
  //   *
  //   * @see SolrCoreAware
  //   */
  //  public void registerCommitCallback( SolrEventListener listener )
  //  {
  //    commitCallbacks.add( listener );
  //  }
  //
  //  /**
  //   * NOTE: this function is not thread safe.  However, it is safe to call within the
  //   * <code>inform( SolrCore core )</code> function for <code>SolrCoreAware</code> classes.
  //   * Outside <code>inform</code>, this could potentially throw a ConcurrentModificationException
  //   *
  //   * @see SolrCoreAware
  //   */
  //  public void registerOptimizeCallback( SolrEventListener listener )
  //  {
  //    optimizeCallbacks.add( listener );
  //  }
  }
  
  
  
  