evolvedbinary / elemental / 982

Committed 29 Apr 2025 08:34PM UTC coverage: 56.409% (+0.007%) from 56.402%

Build # 982

Build Type

push

circleci

Committed by

adamretter

Commit Message

[feature] Improve README.md badges

Run Details

28451 of 55847 branches covered (50.94%)

Branch coverage included in aggregate %.

77468 of 131924 relevant lines covered (58.72%)

0.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.48

/extensions/indexes/range/src/main/java/org/exist/indexing/range/RangeIndexConfigElement.java

/*
 * Elemental
 * Copyright (C) 2024, Evolved Binary Ltd
 *
 * admin@evolvedbinary.com
 * https://www.evolvedbinary.com | https://www.elemental.xyz
 *
 * Use of this software is governed by the Business Source License 1.1
 * included in the LICENSE file and at www.mariadb.com/bsl11.
 *
 * Change Date: 2028-04-27
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by the Apache License, Version 2.0.
 *
 * Additional Use Grant: Production use of the Licensed Work for a permitted
 * purpose. A Permitted Purpose is any purpose other than a Competing Use.
 * A Competing Use means making the Software available to others in a commercial
 * product or service that: substitutes for the Software; substitutes for any
 * other product or service we offer using the Software that exists as of the
 * date we make the Software available; or offers the same or substantially
 * similar functionality as the Software.
 *
 * NOTE: Parts of this file contain code from 'The eXist-db Authors'.
 *       The original license header is included below.
 *
 * =====================================================================
 *
 * eXist-db Open Source Native XML Database
 * Copyright (C) 2001 The eXist-db Authors
 *
 * info@exist-db.org
 * http://www.exist-db.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
package org.exist.indexing.range;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.BytesRefBuilder;
import org.apache.lucene.util.NumericUtils;
import org.exist.dom.QName;
import org.exist.indexing.lucene.LuceneIndexConfig;
import org.exist.storage.NodePath;
import org.exist.util.DatabaseConfigurationException;
import org.exist.util.XMLString;
import org.exist.xquery.XPathException;
import org.exist.xquery.value.*;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

import javax.xml.datatype.XMLGregorianCalendar;
import java.io.IOException;
import java.util.Map;

import static org.exist.indexing.lucene.LuceneIndexConfig.MATCH_ATTR;
import static org.exist.indexing.lucene.LuceneIndexConfig.QNAME_ATTR;
import static org.exist.indexing.lucene.LuceneIndexConfig.TYPE_ATTR;

public class RangeIndexConfigElement {

    protected final static String FILTER_ELEMENT = "filter";

    protected NodePath path = null;
    private int type = Type.STRING;
    private RangeIndexConfigElement nextConfig = null;
    protected boolean isQNameIndex = false;
    protected RangeIndexAnalyzer analyzer = new RangeIndexAnalyzer();
    protected boolean includeNested = false;
    protected boolean caseSensitive = true;
    protected boolean usesCollation = false;
    protected int wsTreatment = XMLString.SUPPRESS_NONE;
    private org.exist.indexing.range.conversion.TypeConverter typeConverter = null;

    public RangeIndexConfigElement(Element node, Map<String, String> namespaces) throws DatabaseConfigurationException {
        String match = node.getAttribute(MATCH_ATTR);
        if (!match.isEmpty()) {
            try {
                path = new NodePath(namespaces, match);
                if (path.length() == 0)
                    throw new DatabaseConfigurationException("Range index module: Invalid match path in collection config: " + match);
            } catch (IllegalArgumentException e) {
                throw new DatabaseConfigurationException("Range index module: invalid qname in configuration: " + e.getMessage());
            }
        } else if (node.hasAttribute(QNAME_ATTR)) {
            QName qname = LuceneIndexConfig.parseQName(node, namespaces);
            path = new NodePath(NodePath.SKIP);
            path.addComponent(qname);
            isQNameIndex = true;
        }
        String typeStr = node.getAttribute(TYPE_ATTR);
        if (!typeStr.isEmpty()) {
            try {
                this.type = Type.getType(typeStr);
            } catch (XPathException e) {
                throw new DatabaseConfigurationException("Invalid type declared for range index on " + match + ": " + typeStr);
            }
        }

        parseChildren(node);

        String collation = node.getAttribute("collation");
        if (!collation.isEmpty()) {
            analyzer.addCollation(collation);
            usesCollation = true;
        }
        String nested = node.getAttribute("nested");
        includeNested = nested.isEmpty() || nested.equalsIgnoreCase("yes");

        // normalize whitespace if whitespace="normalize"
        String whitespace = node.getAttribute("whitespace");
        if ("trim".equalsIgnoreCase(whitespace)) {
            wsTreatment = XMLString.SUPPRESS_BOTH;
        } else if ("normalize".equalsIgnoreCase(whitespace)) {
            wsTreatment = XMLString.NORMALIZE;
        }

        String caseStr = node.getAttribute("case");
        if (!caseStr.isEmpty()) {
            caseSensitive = caseStr.equalsIgnoreCase("yes");
        }
        String custom = node.getAttribute("converter");
        if (!custom.isEmpty()) {
            try {
                Class customClass = Class.forName(custom);
                typeConverter = (org.exist.indexing.range.conversion.TypeConverter) customClass.newInstance();
            } catch (ClassNotFoundException e) {
                RangeIndex.LOG.warn("Class for custom-type not found: {}", custom);
            } catch (InstantiationException | IllegalAccessException e) {
                RangeIndex.LOG.warn("Failed to initialize custom-type: {}", custom, e);
            }
        }
    }

    private void parseChildren(Node root) throws DatabaseConfigurationException {
        Node child = root.getFirstChild();
        while (child != null) {
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                if (FILTER_ELEMENT.equals(child.getLocalName())) {
                    analyzer.addFilter((Element) child);
                }
            }
            child = child.getNextSibling();
        }
    }

    public Field convertToField(String fieldName, String content) throws IOException {
        // check if a converter is defined for this index to handle on-the-fly conversions
        final org.exist.indexing.range.conversion.TypeConverter custom = getTypeConverter(fieldName);
        if (custom != null) {
            return custom.toField(fieldName, content);
        }
        // no converter: handle default types
        final int fieldType = getType(fieldName);
        try {
            switch (fieldType) {
                case Type.INTEGER:
                case Type.LONG:
                case Type.UNSIGNED_LONG:
                    long lvalue = Long.parseLong(content);
                    return new LongField(fieldName, lvalue, LongField.TYPE_NOT_STORED);
                case Type.INT:
                case Type.UNSIGNED_INT:
                case Type.SHORT:
                case Type.UNSIGNED_SHORT:
                    int ivalue = Integer.parseInt(content);
                    return new IntField(fieldName, ivalue, IntField.TYPE_NOT_STORED);
                case Type.DECIMAL:
                case Type.DOUBLE:
                    double dvalue = Double.parseDouble(content);
                    return new DoubleField(fieldName, dvalue, DoubleField.TYPE_NOT_STORED);
                case Type.FLOAT:
                    float fvalue = Float.parseFloat(content);
                    return new FloatField(fieldName, fvalue, FloatField.TYPE_NOT_STORED);
                case Type.DATE:
                    DateValue dv = new DateValue(content);
                    long dl = dateToLong(dv);
                    return new LongField(fieldName, dl, LongField.TYPE_NOT_STORED);
                case Type.TIME:
                    TimeValue tv = new TimeValue(content);
                    long tl = timeToLong(tv);
                    return new LongField(fieldName, tl, LongField.TYPE_NOT_STORED);
                case Type.DATE_TIME:
                    DateTimeValue dtv = new DateTimeValue(content);
                    String dateStr = dateTimeToString(dtv);
                    return new TextField(fieldName, dateStr, Field.Store.NO);
                default:
                    return new TextField(fieldName, content, Field.Store.NO);
            }
        } catch (NumberFormatException | XPathException e) {
            // wrong type: ignore
        }
        return null;
    }

    public static BytesRef convertToBytes(final AtomicValue content) throws XPathException {
        final BytesRefBuilder bytes = new BytesRefBuilder();
        switch(content.getType()) {
            case Type.INTEGER:
            case Type.LONG:
            case Type.UNSIGNED_LONG:
                NumericUtils.longToPrefixCoded(((IntegerValue)content).getLong(), 0, bytes);
                break;

            case Type.SHORT:
            case Type.UNSIGNED_SHORT:
            case Type.INT:
            case Type.UNSIGNED_INT:
                NumericUtils.intToPrefixCoded(((IntegerValue)content).getInt(), 0, bytes);
                break;

            case Type.DECIMAL:
                final long dv = NumericUtils.doubleToSortableLong(((DecimalValue)content).getDouble());
                NumericUtils.longToPrefixCoded(dv, 0, bytes);
                break;

            case Type.DOUBLE:
                final long lv = NumericUtils.doubleToSortableLong(((DoubleValue)content).getDouble());
                NumericUtils.longToPrefixCoded(lv, 0, bytes);
                break;

            case Type.FLOAT:
                final int iv = NumericUtils.floatToSortableInt(((FloatValue)content).getValue());
                NumericUtils.longToPrefixCoded(iv, 0, bytes);
                break;

            case Type.DATE:
                final long dl = dateToLong((DateValue)content);
                NumericUtils.longToPrefixCoded(dl, 0, bytes);
                break;

            case Type.TIME:
                final long tl = timeToLong((TimeValue) content);
                NumericUtils.longToPrefixCoded(tl, 0, bytes);
                break;

            case Type.DATE_TIME:
                final String dt = dateTimeToString((DateTimeValue) content);
                bytes.copyChars(dt);
                break;

            default:
                bytes.copyChars(content.getStringValue());
        }
        return bytes.toBytesRef();
    }

    public static long dateToLong(DateValue date) {
        final XMLGregorianCalendar utccal = date.calendar.normalize();
        return ((long)utccal.getYear() << 16) + ((long)utccal.getMonth() << 8) + ((long)utccal.getDay());
    }

    public static long timeToLong(TimeValue time) {
        return time.getTimeInMillis();
    }

    public static String dateTimeToString(DateTimeValue dtv) {
        final XMLGregorianCalendar utccal = dtv.calendar.normalize();
        final StringBuilder sb = new StringBuilder();
        formatNumber(utccal.getMillisecond(), 3, sb);
        formatNumber(utccal.getSecond(), 2, sb);
        formatNumber(utccal.getMinute(), 2, sb);
        formatNumber(utccal.getHour(), 2, sb);
        formatNumber(utccal.getDay(), 2, sb);
        formatNumber(utccal.getMonth(), 2, sb);
        formatNumber(utccal.getYear(), 4, sb);
        return sb.toString();
    }

    public static void formatNumber(int number, int digits, StringBuilder sb) {
        int count = 0;
        long n = number;
        while (n > 0) {
            final int digit = '0' + (int)n % 10;
            sb.insert(0, (char)digit);
            count++;
            if (count == digits) {
                break;
            }
            n = n / 10;
        }
        if (count < digits) {
            for (int i = count; i < digits; i++) {
                sb.insert(0, '0');
            }
        }
    }

    public TextCollector getCollector(NodePath path) {
        return new SimpleTextCollector(this, includeNested, wsTreatment, caseSensitive);
    }

    public Analyzer getAnalyzer() {
        return analyzer;
    }

    public Analyzer getAnalyzer(String field) {
        return analyzer;
    }

    public boolean isCaseSensitive(String fieldName) {
        return caseSensitive;
    }

    public boolean usesCollation() {
        return usesCollation;
    }

    public boolean isComplex() {
        return false;
    }

    public int getType(String fieldName) {
        // no fields: return type
        return type;
    }

    public int getType() {
        return type;
    }

    public org.exist.indexing.range.conversion.TypeConverter getTypeConverter(String fieldName) {
        return typeConverter;
    }

    public NodePath getNodePath() {
        return path;
    }

    public void add(RangeIndexConfigElement config) {
        if (nextConfig == null)
            nextConfig = config;
        else
            nextConfig.add(config);
    }

    public RangeIndexConfigElement getNext() {
        return nextConfig;
    }

    public boolean match(NodePath other) {
        if (isQNameIndex) {
            final QName qn1 = path.getLastComponent();
            final QName qn2 = other.getLastComponent();
            return qn1.getNameType() == qn2.getNameType() && qn2.equals(qn1);
        }
        return other.match(path);
    }

    public boolean find(NodePath other) {
        return match(other);
    }
}

1	/*
2	* Elemental
3	* Copyright (C) 2024, Evolved Binary Ltd
4	*
5	* admin@evolvedbinary.com
6	* https://www.evolvedbinary.com \| https://www.elemental.xyz
7	*
8	* Use of this software is governed by the Business Source License 1.1
9	* included in the LICENSE file and at www.mariadb.com/bsl11.
10	*
11	* Change Date: 2028-04-27
12	*
13	* On the date above, in accordance with the Business Source License, use
14	* of this software will be governed by the Apache License, Version 2.0.
15	*
16	* Additional Use Grant: Production use of the Licensed Work for a permitted
17	* purpose. A Permitted Purpose is any purpose other than a Competing Use.
18	* A Competing Use means making the Software available to others in a commercial
19	* product or service that: substitutes for the Software; substitutes for any
20	* other product or service we offer using the Software that exists as of the
21	* date we make the Software available; or offers the same or substantially
22	* similar functionality as the Software.
23	*
24	* NOTE: Parts of this file contain code from 'The eXist-db Authors'.
25	* The original license header is included below.
26	*
27	* =====================================================================
28	*
29	* eXist-db Open Source Native XML Database
30	* Copyright (C) 2001 The eXist-db Authors
31	*
32	* info@exist-db.org
33	* http://www.exist-db.org
34	*
35	* This library is free software; you can redistribute it and/or
36	* modify it under the terms of the GNU Lesser General Public
37	* License as published by the Free Software Foundation; either
38	* version 2.1 of the License, or (at your option) any later version.
39	*
40	* This library is distributed in the hope that it will be useful,
41	* but WITHOUT ANY WARRANTY; without even the implied warranty of
42	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43	* Lesser General Public License for more details.
44	*
45	* You should have received a copy of the GNU Lesser General Public
46	* License along with this library; if not, write to the Free Software
47	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48	*/
49	package org.exist.indexing.range;
50
51	import org.apache.lucene.analysis.Analyzer;
52	import org.apache.lucene.document.*;
53	import org.apache.lucene.util.BytesRef;
54	import org.apache.lucene.util.BytesRefBuilder;
55	import org.apache.lucene.util.NumericUtils;
56	import org.exist.dom.QName;
57	import org.exist.indexing.lucene.LuceneIndexConfig;
58	import org.exist.storage.NodePath;
59	import org.exist.util.DatabaseConfigurationException;
60	import org.exist.util.XMLString;
61	import org.exist.xquery.XPathException;
62	import org.exist.xquery.value.*;
63	import org.w3c.dom.Element;
64	import org.w3c.dom.Node;
65
66	import javax.xml.datatype.XMLGregorianCalendar;
67	import java.io.IOException;
68	import java.util.Map;
69
70	import static org.exist.indexing.lucene.LuceneIndexConfig.MATCH_ATTR;
71	import static org.exist.indexing.lucene.LuceneIndexConfig.QNAME_ATTR;
72	import static org.exist.indexing.lucene.LuceneIndexConfig.TYPE_ATTR;
73
74	public class RangeIndexConfigElement {
75
76	protected final static String FILTER_ELEMENT = "filter";
77
78	protected NodePath path = null;	1✔
79	private int type = Type.STRING;	1✔
80	private RangeIndexConfigElement nextConfig = null;	1✔
81	protected boolean isQNameIndex = false;	1✔
82	protected RangeIndexAnalyzer analyzer = new RangeIndexAnalyzer();	1✔
83	protected boolean includeNested = false;	1✔
84	protected boolean caseSensitive = true;	1✔
85	protected boolean usesCollation = false;	1✔
86	protected int wsTreatment = XMLString.SUPPRESS_NONE;	1✔
87	private org.exist.indexing.range.conversion.TypeConverter typeConverter = null;	1✔
88
89	public RangeIndexConfigElement(Element node, Map<String, String> namespaces) throws DatabaseConfigurationException {	1✔
90	String match = node.getAttribute(MATCH_ATTR);	1✔
91	if (!match.isEmpty()) {	1✔
92	try {
93	path = new NodePath(namespaces, match);	1✔
94	if (path.length() == 0)	1!
95	throw new DatabaseConfigurationException("Range index module: Invalid match path in collection config: " + match);	×
96	} catch (IllegalArgumentException e) {	×
97	throw new DatabaseConfigurationException("Range index module: invalid qname in configuration: " + e.getMessage());	×
98	}	1✔
99	} else if (node.hasAttribute(QNAME_ATTR)) {	1!
100	QName qname = LuceneIndexConfig.parseQName(node, namespaces);	1✔
101	path = new NodePath(NodePath.SKIP);	1✔
102	path.addComponent(qname);	1✔
103	isQNameIndex = true;	1✔
104	}
105	String typeStr = node.getAttribute(TYPE_ATTR);	1✔
106	if (!typeStr.isEmpty()) {	1✔
107	try {
108	this.type = Type.getType(typeStr);	1✔
109	} catch (XPathException e) {	×
110	throw new DatabaseConfigurationException("Invalid type declared for range index on " + match + ": " + typeStr);	×
111	}	1✔
112	}
113
114	parseChildren(node);	1✔
115
116	String collation = node.getAttribute("collation");	1✔
117	if (!collation.isEmpty()) {	1✔
118	analyzer.addCollation(collation);	1✔
119	usesCollation = true;	1✔
120	}
121	String nested = node.getAttribute("nested");	1✔
122	includeNested = nested.isEmpty() \|\| nested.equalsIgnoreCase("yes");	1!
123
124	// normalize whitespace if whitespace="normalize"
125	String whitespace = node.getAttribute("whitespace");	1✔
126	if ("trim".equalsIgnoreCase(whitespace)) {	1!
127	wsTreatment = XMLString.SUPPRESS_BOTH;	×
128	} else if ("normalize".equalsIgnoreCase(whitespace)) {	1✔
129	wsTreatment = XMLString.NORMALIZE;	1✔
130	}
131
132	String caseStr = node.getAttribute("case");	1✔
133	if (!caseStr.isEmpty()) {	1✔
134	caseSensitive = caseStr.equalsIgnoreCase("yes");	1✔
135	}
136	String custom = node.getAttribute("converter");	1✔
137	if (!custom.isEmpty()) {	1✔
138	try {
139	Class customClass = Class.forName(custom);	1✔
140	typeConverter = (org.exist.indexing.range.conversion.TypeConverter) customClass.newInstance();	1✔
141	} catch (ClassNotFoundException e) {	×
142	RangeIndex.LOG.warn("Class for custom-type not found: {}", custom);	×
143	} catch (InstantiationException \| IllegalAccessException e) {	×
144	RangeIndex.LOG.warn("Failed to initialize custom-type: {}", custom, e);	×
145	}	1✔
146	}
147	}	1✔
148
149	private void parseChildren(Node root) throws DatabaseConfigurationException {
150	Node child = root.getFirstChild();	1✔
151	while (child != null) {	1✔
152	if (child.getNodeType() == Node.ELEMENT_NODE) {	1!
153	if (FILTER_ELEMENT.equals(child.getLocalName())) {	1✔
154	analyzer.addFilter((Element) child);	1✔
155	}
156	}
157	child = child.getNextSibling();	1✔
158	}
159	}	1✔
160
161	public Field convertToField(String fieldName, String content) throws IOException {
162	// check if a converter is defined for this index to handle on-the-fly conversions
163	final org.exist.indexing.range.conversion.TypeConverter custom = getTypeConverter(fieldName);	1✔
164	if (custom != null) {	1✔
165	return custom.toField(fieldName, content);	1✔
166	}
167	// no converter: handle default types
168	final int fieldType = getType(fieldName);	1✔
169	try {
170	switch (fieldType) {	1!
171	case Type.INTEGER:
172	case Type.LONG:
173	case Type.UNSIGNED_LONG:
174	long lvalue = Long.parseLong(content);	1✔
175	return new LongField(fieldName, lvalue, LongField.TYPE_NOT_STORED);	1✔
176	case Type.INT:
177	case Type.UNSIGNED_INT:
178	case Type.SHORT:
179	case Type.UNSIGNED_SHORT:
180	int ivalue = Integer.parseInt(content);	1✔
181	return new IntField(fieldName, ivalue, IntField.TYPE_NOT_STORED);	1✔
182	case Type.DECIMAL:
183	case Type.DOUBLE:
184	double dvalue = Double.parseDouble(content);	×
185	return new DoubleField(fieldName, dvalue, DoubleField.TYPE_NOT_STORED);	×
186	case Type.FLOAT:
187	float fvalue = Float.parseFloat(content);	×
188	return new FloatField(fieldName, fvalue, FloatField.TYPE_NOT_STORED);	×
189	case Type.DATE:
190	DateValue dv = new DateValue(content);	1✔
191	long dl = dateToLong(dv);	1✔
192	return new LongField(fieldName, dl, LongField.TYPE_NOT_STORED);	1✔
193	case Type.TIME:
194	TimeValue tv = new TimeValue(content);	1✔
195	long tl = timeToLong(tv);	1✔
196	return new LongField(fieldName, tl, LongField.TYPE_NOT_STORED);	1✔
197	case Type.DATE_TIME:
198	DateTimeValue dtv = new DateTimeValue(content);	1✔
199	String dateStr = dateTimeToString(dtv);	1✔
200	return new TextField(fieldName, dateStr, Field.Store.NO);	1✔
201	default:
202	return new TextField(fieldName, content, Field.Store.NO);	1✔
203	}
204	} catch (NumberFormatException \| XPathException e) {	×
205	// wrong type: ignore
206	}
207	return null;	×
208	}
209
210	public static BytesRef convertToBytes(final AtomicValue content) throws XPathException {
211	final BytesRefBuilder bytes = new BytesRefBuilder();	1✔
212	switch(content.getType()) {	1!
213	case Type.INTEGER:
214	case Type.LONG:
215	case Type.UNSIGNED_LONG:
216	NumericUtils.longToPrefixCoded(((IntegerValue)content).getLong(), 0, bytes);	1✔
217	break;	1✔
218
219	case Type.SHORT:
220	case Type.UNSIGNED_SHORT:
221	case Type.INT:
222	case Type.UNSIGNED_INT:
223	NumericUtils.intToPrefixCoded(((IntegerValue)content).getInt(), 0, bytes);	1✔
224	break;	1✔
225
226	case Type.DECIMAL:
227	final long dv = NumericUtils.doubleToSortableLong(((DecimalValue)content).getDouble());	×
228	NumericUtils.longToPrefixCoded(dv, 0, bytes);	×
229	break;	×
230
231	case Type.DOUBLE:
232	final long lv = NumericUtils.doubleToSortableLong(((DoubleValue)content).getDouble());	×
233	NumericUtils.longToPrefixCoded(lv, 0, bytes);	×
234	break;	×
235
236	case Type.FLOAT:
237	final int iv = NumericUtils.floatToSortableInt(((FloatValue)content).getValue());	×
238	NumericUtils.longToPrefixCoded(iv, 0, bytes);	×
239	break;	×
240
241	case Type.DATE:
242	final long dl = dateToLong((DateValue)content);	1✔
243	NumericUtils.longToPrefixCoded(dl, 0, bytes);	1✔
244	break;	1✔
245
246	case Type.TIME:
247	final long tl = timeToLong((TimeValue) content);	1✔
248	NumericUtils.longToPrefixCoded(tl, 0, bytes);	1✔
249	break;	1✔
250
251	case Type.DATE_TIME:
252	final String dt = dateTimeToString((DateTimeValue) content);	1✔
253	bytes.copyChars(dt);	1✔
254	break;	1✔
255
256	default:
257	bytes.copyChars(content.getStringValue());	×
258	}
259	return bytes.toBytesRef();	1✔
260	}
261
262	public static long dateToLong(DateValue date) {
263	final XMLGregorianCalendar utccal = date.calendar.normalize();	1✔
264	return ((long)utccal.getYear() << 16) + ((long)utccal.getMonth() << 8) + ((long)utccal.getDay());	1✔
265	}
266
267	public static long timeToLong(TimeValue time) {
268	return time.getTimeInMillis();	1✔
269	}
270
271	public static String dateTimeToString(DateTimeValue dtv) {
272	final XMLGregorianCalendar utccal = dtv.calendar.normalize();	1✔
273	final StringBuilder sb = new StringBuilder();	1✔
274	formatNumber(utccal.getMillisecond(), 3, sb);	1✔
275	formatNumber(utccal.getSecond(), 2, sb);	1✔
276	formatNumber(utccal.getMinute(), 2, sb);	1✔
277	formatNumber(utccal.getHour(), 2, sb);	1✔
278	formatNumber(utccal.getDay(), 2, sb);	1✔
279	formatNumber(utccal.getMonth(), 2, sb);	1✔
280	formatNumber(utccal.getYear(), 4, sb);	1✔
281	return sb.toString();	1✔
282	}
283
284	public static void formatNumber(int number, int digits, StringBuilder sb) {
285	int count = 0;	1✔
286	long n = number;	1✔
287	while (n > 0) {	1✔
288	final int digit = '0' + (int)n % 10;	1✔
289	sb.insert(0, (char)digit);	1✔
290	count++;	1✔
291	if (count == digits) {	1✔
292	break;	1✔
293	}
294	n = n / 10;	1✔
295	}	1✔
296	if (count < digits) {	1✔
297	for (int i = count; i < digits; i++) {	1✔
298	sb.insert(0, '0');	1✔
299	}
300	}
301	}	1✔
302
303	public TextCollector getCollector(NodePath path) {
304	return new SimpleTextCollector(this, includeNested, wsTreatment, caseSensitive);	1✔
305	}
306
307	public Analyzer getAnalyzer() {
308	return analyzer;	1✔
309	}
310
311	public Analyzer getAnalyzer(String field) {
312	return analyzer;	1✔
313	}
314
315	public boolean isCaseSensitive(String fieldName) {
316	return caseSensitive;	1✔
317	}
318
319	public boolean usesCollation() {
320	return usesCollation;	1✔
321	}
322
323	public boolean isComplex() {
324	return false;	1✔
325	}
326
327	public int getType(String fieldName) {
328	// no fields: return type
329	return type;	1✔
330	}
331
332	public int getType() {
333	return type;	1✔
334	}
335
336	public org.exist.indexing.range.conversion.TypeConverter getTypeConverter(String fieldName) {
337	return typeConverter;	1✔
338	}
339
340	public NodePath getNodePath() {
341	return path;	1✔
342	}
343
344	public void add(RangeIndexConfigElement config) {
345	if (nextConfig == null)	1✔
346	nextConfig = config;	1✔
347	else
348	nextConfig.add(config);	1✔
349	}	1✔
350
351	public RangeIndexConfigElement getNext() {
352	return nextConfig;	1✔
353	}
354
355	public boolean match(NodePath other) {
356	if (isQNameIndex) {	1✔
357	final QName qn1 = path.getLastComponent();	1✔
358	final QName qn2 = other.getLastComponent();	1✔
359	return qn1.getNameType() == qn2.getNameType() && qn2.equals(qn1);	1✔
360	}
361	return other.match(path);	1✔
362	}
363
364	public boolean find(NodePath other) {
365	return match(other);	1✔
366	}
367	}

evolvedbinary / elemental / 982

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous