import org.apache.solr.schema.DateField; //导入依赖的package包/类
/**
 * Can be used to transform input values based on their {@link org.apache.solr.schema.SchemaField}
 * <p/>
 * This implementation only formats dates using the {@link org.apache.solr.common.util.DateUtil}.
 *
 * @param val    The value to transform
 * @param schFld The {@link org.apache.solr.schema.SchemaField}
 * @return The potentially new value.
 */
protected String transformValue(String val, SchemaField schFld) {
  String result = val;
  if (schFld != null && schFld.getType() instanceof DateField) {
    //try to transform the date
    try {
      Date date = DateUtil.parseDate(val, dateFormats);
      DateFormat df = DateUtil.getThreadLocalDateFormat();
      result = df.format(date);

    } catch (Exception e) {
      // Let the specific fieldType handle errors
      // throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, "Invalid value: " + val + " for field: " + schFld, e);
    }
  }
  return result;
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
protected void handleEnable(boolean enable) throws SolrException {
  if (healthcheck == null) {
    throw new SolrException(SolrException.ErrorCode.SERVICE_UNAVAILABLE, 
      "No healthcheck file defined.");
  }
  if ( enable ) {
    try {
      // write out when the file was created
      FileUtils.write(healthcheck, 
                      DateField.formatExternal(new Date()), "UTF-8");
    } catch (IOException e) {
      throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, 
                              "Unable to write healthcheck flag file", e);
    }
  } else {
    if (healthcheck.exists() && !healthcheck.delete()){
      throw new SolrException(SolrException.ErrorCode.NOT_FOUND,
                              "Did not successfully delete healthcheck file: "
                              +healthcheck.getAbsolutePath());
    }
  }
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
private void appendValue(Object value, StringBuilder buf, String key) {
	if (value instanceof List) {
		Iterator<String>itr = ((List<String>)value).iterator();
		while (itr.hasNext()) 
			buf.append("    <"+IXMLFields.VALUE+"><![CDATA["+itr.next()+"]]></"+IXMLFields.VALUE+">\n");

	} else {
		//MUST TEST FOR DATES
		if (key.equals(ITopicQuestsOntology.CREATED_DATE_PROPERTY) || 
			key.equals(ITopicQuestsOntology.LAST_EDIT_DATE_PROPERTY)) {
			if (value instanceof Date) {
				Date d = (Date)(value); //
				buf.append("    <"+IXMLFields.VALUE+"><![CDATA["+DateField.formatExternal(d)+"]]></"+IXMLFields.VALUE+">\n");
			} else
				buf.append("    <"+IXMLFields.VALUE+"><![CDATA["+value+"]]></"+IXMLFields.VALUE+">\n");
		} else
			buf.append("    <"+IXMLFields.VALUE+"><![CDATA["+value+"]]></"+IXMLFields.VALUE+">\n");
	}
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
/**
 * @deprecated Use rangeCount(SchemaField,String,String,boolean,boolean) which is more generalized
 */
@Deprecated
protected int rangeCount(SchemaField sf, Date low, Date high,
                         boolean iLow, boolean iHigh) throws IOException {
  Query rangeQ = ((DateField)(sf.getType())).getRangeQuery(null, sf, low, high, iLow, iHigh);
  return searcher.numDocs(rangeQ, docs);
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
public DateRangeEndpointCalculator(final SchemaField f, 
                                   final Date now) { 
  super(f); 
  this.now = now;
  if (! (field.getType() instanceof DateField) ) {
    throw new IllegalArgumentException
      ("SchemaField must use filed type extending DateField");
  }
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
/**
 * @deprecated Use rangeCount(SchemaField,String,String,boolean,boolean) which is more generalized
 */
@Deprecated
protected int rangeCount(SchemaField sf, Date low, Date high,
                         boolean iLow, boolean iHigh) throws IOException {
  Query rangeQ = ((DateField)(sf.getType())).getRangeQuery(null, sf,low,high,iLow,iHigh);
  return searcher.numDocs(rangeQ , docs);
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
@Override
public Object parse(String value) {
	try {
		return DateField.parseDate(value);
	} catch(ParseException e) {
		throw new RuntimeException("value='" + value + "' parse date error", e);
	}
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
private Date parseDate(String s) throws Exception {
		DateField d  = new DateField();
		return d.parseMath(null, s);
//		try {
//			if (s.endsWith("Z") || s.endsWith("z"))
//				return DateField.parseDate(s.substring(0,s.length()-1));
//			return DateField.parseDate(s);
//		} catch (java.text.ParseException e ){
//			DateField d  = new DateField();
//			return d.parseMath(null, s);
//		}
	}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
void getFacetRangeCounts(String facetRange, NamedList<Object> resOuter)
    throws IOException, SyntaxError {

  final IndexSchema schema = searcher.getSchema();

  parseParams(FacetParams.FACET_RANGE, facetRange);
  String f = facetValue;

  final SchemaField sf = schema.getField(f);
  final FieldType ft = sf.getType();

  RangeEndpointCalculator<?> calc = null;

  if (ft instanceof TrieField) {
    final TrieField trie = (TrieField)ft;

    switch (trie.getType()) {
      case FLOAT:
        calc = new FloatRangeEndpointCalculator(sf);
        break;
      case DOUBLE:
        calc = new DoubleRangeEndpointCalculator(sf);
        break;
      case INTEGER:
        calc = new IntegerRangeEndpointCalculator(sf);
        break;
      case LONG:
        calc = new LongRangeEndpointCalculator(sf);
        break;
      default:
        throw new SolrException
            (SolrException.ErrorCode.BAD_REQUEST,
                "Unable to range facet on tried field of unexpected type:" + f);
    }
  } else if (ft instanceof DateField) {
    calc = new DateRangeEndpointCalculator(sf, null);
  } else if (ft instanceof SortableIntField) {
    calc = new IntegerRangeEndpointCalculator(sf);
  } else if (ft instanceof SortableLongField) {
    calc = new LongRangeEndpointCalculator(sf);
  } else if (ft instanceof SortableFloatField) {
    calc = new FloatRangeEndpointCalculator(sf);
  } else if (ft instanceof SortableDoubleField) {
    calc = new DoubleRangeEndpointCalculator(sf);
  } else {
    throw new SolrException
        (SolrException.ErrorCode.BAD_REQUEST,
            "Unable to range facet on field:" + sf);
  }

  resOuter.add(key, getFacetRangeCounts(sf, calc));
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
@Override
public String formatValue(Date val) {
  return ((DateField)field.getType()).toExternal(val);
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
@Override
protected Date parseVal(String rawval) {
  return ((DateField)field.getType()).parseMath(now, rawval);
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
public void writeDate(String name, Date val) throws IOException {
  writeDate(name, DateField.formatExternal(val));
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
public void run() {
  // setup the request context early so the logging (including any from 
  // shouldWeDoPeriodicDelete() ) includes the core context info
  final SolrQueryRequest req = new LocalSolrQueryRequest
    (factory.core, Collections.<String,String[]>emptyMap());
  try {
    final SolrQueryResponse rsp = new SolrQueryResponse();
    SolrRequestInfo.setRequestInfo(new SolrRequestInfo(req, rsp));
    try {
      
      if (! factory.iAmInChargeOfPeriodicDeletes() ) {
        // No-Op
        return;
      }
      log.info("Begining periodic deletion of expired docs");

      UpdateRequestProcessorChain chain = core.getUpdateProcessingChain(deleteChainName);
      UpdateRequestProcessor proc = chain.createProcessor(req, rsp);
      if (null == proc) {
        log.warn("No active processors, skipping automatic deletion " + 
                 "of expired docs using chain: {}", deleteChainName);
        return;
      }
      try {
        DeleteUpdateCommand del = new DeleteUpdateCommand(req);
        del.setQuery("{!cache=false}" + expireField + ":[* TO " +
                     DateField.formatExternal(SolrRequestInfo.getRequestInfo().getNOW())
                     + "]");
        proc.processDelete(del);
        
        // TODO: should this be more configurable? 
        // TODO: in particular: should hard commit be optional?
        CommitUpdateCommand commit = new CommitUpdateCommand(req, false);
        commit.softCommit = true;
        commit.openSearcher = true;
        proc.processCommit(commit);
        
      } finally {
        proc.finish();
      }

      log.info("Finished periodic deletion of expired docs");
    } catch (IOException ioe) {
      log.error("IOException in periodic deletion of expired docs: " +
                ioe.getMessage(), ioe);
      // DO NOT RETHROW: ScheduledExecutor will supress subsequent executions
    } catch (RuntimeException re) {
      log.error("Runtime error in periodic deletion of expired docs: " + 
                re.getMessage(), re);
      // DO NOT RETHROW: ScheduledExecutor will supress subsequent executions
    } finally {
      SolrRequestInfo.clearRequestInfo();
    }
  } finally {
    req.close();
  }
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
private void updateCommits(List<? extends IndexCommit> commits) {
  // to be safe, we should only call delete on a commit point passed to us
  // in this specific call (may be across diff IndexWriter instances).
  // this will happen rarely, so just synchronize everything
  // for safety and to avoid race conditions

  synchronized (this) {
    long maxCommitAgeTimeStamp = -1L;
    IndexCommit newest = commits.get(commits.size() - 1);
    // SOLR-4547: Removed the filenames from this log entry because this
    // method is only called from methods that have just logged them
    // at DEBUG.
    log.info("newest commit generation = " + newest.getGeneration());
    int singleSegKept = (newest.getSegmentCount() == 1) ? 1 : 0;
    int totalKept = 1;

    // work our way from newest to oldest, skipping the first since we always want to keep it.
    for (int i=commits.size()-2; i>=0; i--) {
      IndexCommit commit = commits.get(i);

      // delete anything too old, regardless of other policies
      try {
        if (maxCommitAge != null) {
          if (maxCommitAgeTimeStamp==-1) {
            DateMathParser dmp = new DateMathParser(DateField.UTC, Locale.ROOT);
            maxCommitAgeTimeStamp = dmp.parseMath(maxCommitAge).getTime();
          }
          if (IndexDeletionPolicyWrapper.getCommitTimestamp(commit) < maxCommitAgeTimeStamp) {
            commit.delete();
            continue;
          }
        }
      } catch (Exception e) {
        log.warn("Exception while checking commit point's age for deletion", e);
      }

      if (singleSegKept < maxOptimizedCommitsToKeep && commit.getSegmentCount() == 1) {
        totalKept++;
        singleSegKept++;
        continue;
      }

      if (totalKept < maxCommitsToKeep) {
        totalKept++;
        continue;
      }
                                                
      commit.delete();
    }

  } // end synchronized
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
@Test
public void testTrieDateRangeSearch() throws Exception {
  for (int i = 0; i < 10; i++) {
    assertU(adoc("id", String.valueOf(i), "tdate", "1995-12-31T23:" + (i < 10 ? "0" + i : i) + ":59.999Z"));
  }
  assertU(commit());
  SolrQueryRequest req = req("q", "*:*", "fq", "tdate:[1995-12-31T23:00:59.999Z TO 1995-12-31T23:04:59.999Z]");
  assertQ("Range filter must match only 5 documents", req, "//*[@numFound='5']");

  // Test open ended range searches
  assertQ("Range filter tint:[1995-12-31T23:00:59.999Z to *] must match 10 documents", req("q", "*:*", "fq", "tdate:[1995-12-31T23:00:59.999Z TO *]"), "//*[@numFound='10']");
  assertQ("Range filter tint:[* to 1995-12-31T23:09:59.999Z] must match 10 documents", req("q", "*:*", "fq", "tdate:[* TO 1995-12-31T23:09:59.999Z]"), "//*[@numFound='10']");
  assertQ("Range filter tint:[* to *] must match 10 documents", req("q", "*:*", "fq", "tdate:[* TO *]"), "//*[@numFound='10']");

  // Test date math syntax
  SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.ROOT);
  format.setTimeZone(TimeZone.getTimeZone("UTC"));

  assertU(delQ("*:*"));
  DateMathParser dmp = new DateMathParser(DateField.UTC, Locale.ROOT);
  String largestDate = "";
  for (int i = 0; i < 10; i++) {
    // index 10 days starting with today
    String d = format.format(i == 0 ? dmp.parseMath("/DAY") : dmp.parseMath("/DAY+" + i + "DAYS"));
    assertU(adoc("id", String.valueOf(i), "tdate", d));
    if (i == 9) largestDate = d;
  }
  assertU(commit());
  assertQ("Range filter must match only 10 documents", req("q", "*:*", "fq", "tdate:[* TO *]"), "//*[@numFound='10']");
  req = req("q", "*:*", "fq", "tdate:[NOW/DAY TO NOW/DAY+5DAYS]");
  assertQ("Range filter must match only 6 documents", req, "//*[@numFound='6']");

  // Test Term Queries
  assertU(adoc("id", "11", "tdate", "1995-12-31T23:59:59.999Z"));
  assertU(commit());
  assertQ("Term query must match only 1 document", req("q", "tdate:1995-12-31T23\\:59\\:59.999Z"), "//*[@numFound='1']");
  assertQ("Term query must match only 1 document", req("q", "*:*", "fq", "tdate:1995-12-31T23\\:59\\:59.999Z"), "//*[@numFound='1']");

  // Sorting
  assertQ("Sort descending does not work correctly on tdate fields", req("q", "*:*", "sort", "tdate desc"), "//*[@numFound='11']", "//date[@name='tdate'][.='" + largestDate + "']");
  assertQ("Sort ascending does not work correctly on tdate fields", req("q", "*:*", "sort", "tdate asc"), "//*[@numFound='11']", "//date[@name='tdate'][.='1995-12-31T23:59:59.999Z']");

  // Function queries
  assertQ("Function queries does not work correctly on tdate fields", req("q", "_val_:\"sum(tdate,1.0)\""), "//*[@numFound='11']", "//date[@name='tdate'][.='" + largestDate + "']");
}
 

import org.apache.solr.schema.DateField; //导入依赖的package包/类
private void updateCommits(List<IndexCommit> commits) {
  // to be safe, we should only call delete on a commit point passed to us
  // in this specific call (may be across diff IndexWriter instances).
  // this will happen rarely, so just synchronize everything
  // for safety and to avoid race conditions

  synchronized (this) {
    long maxCommitAgeTimeStamp = -1L;
    IndexCommit newest = commits.get(commits.size() - 1);
    try {
      log.info("newest commit = " + newest.getGeneration() + newest.getFileNames().toString());
    } catch (IOException e1) {
      throw new RuntimeException();
    }

    int singleSegKept = (newest.getSegmentCount() == 1) ? 1 : 0;
    int totalKept = 1;

    // work our way from newest to oldest, skipping the first since we always want to keep it.
    for (int i=commits.size()-2; i>=0; i--) {
      IndexCommit commit = commits.get(i);

      // delete anything too old, regardless of other policies
      try {
        if (maxCommitAge != null) {
          if (maxCommitAgeTimeStamp==-1) {
            DateMathParser dmp = new DateMathParser(DateField.UTC, Locale.ROOT);
            maxCommitAgeTimeStamp = dmp.parseMath(maxCommitAge).getTime();
          }
          if (IndexDeletionPolicyWrapper.getCommitTimestamp(commit) < maxCommitAgeTimeStamp) {
            commit.delete();
            continue;
          }
        }
      } catch (Exception e) {
        log.warn("Exception while checking commit point's age for deletion", e);
      }

      if (singleSegKept < maxOptimizedCommitsToKeep && commit.getSegmentCount() == 1) {
        totalKept++;
        singleSegKept++;
        continue;
      }

      if (totalKept < maxCommitsToKeep) {
        totalKept++;
        continue;
      }
                                                
      commit.delete();
    }

  } // end synchronized
}