1 /* Copyright (C) 2021 Free Software Foundation, Inc.
4 This file is part of GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
24 #include "IndexMap2D.h"
25 #include "DbeSession.h"
26 #include "FilterExp.h"
32 get_prof_data_type_name (int t)
36 case DATA_SAMPLE: return NTXT("PROFDATA_TYPE_SAMPLE");
37 case DATA_GCEVENT: return NTXT("PROFDATA_TYPE_GCEVENT");
38 case DATA_HEAPSZ: return NTXT("PROFDATA_TYPE_HEAPSZ");
39 case DATA_CLOCK: return NTXT("PROFDATA_TYPE_CLOCK");
40 case DATA_HWC: return NTXT("PROFDATA_TYPE_HWC");
41 case DATA_SYNCH: return NTXT("PROFDATA_TYPE_SYNCH");
42 case DATA_HEAP: return NTXT("PROFDATA_TYPE_HEAP");
43 case DATA_OMP: return NTXT("PROFDATA_TYPE_OMP");
44 case DATA_OMP2: return NTXT("PROFDATA_TYPE_OMP2");
45 case DATA_OMP3: return NTXT("PROFDATA_TYPE_OMP3");
46 case DATA_OMP4: return NTXT("PROFDATA_TYPE_OMP4");
47 case DATA_OMP5: return NTXT("PROFDATA_TYPE_OMP5");
48 case DATA_IOTRACE: return NTXT("PROFDATA_TYPE_IOTRACE");
50 return NTXT ("PROFDATA_TYPE_ERROR");
55 get_prof_data_type_uname (int t)
59 case DATA_SAMPLE: return GTXT("Process-wide Resource Utilization");
60 case DATA_GCEVENT: return GTXT("Java Garbage Collection Events");
61 case DATA_HEAPSZ: return GTXT("Heap Size");
62 case DATA_CLOCK: return GTXT("Clock Profiling");
63 case DATA_HWC: return GTXT("HW Counter Profiling");
64 case DATA_SYNCH: return GTXT("Synchronization Tracing");
65 case DATA_HEAP: return GTXT("Heap Tracing");
66 case DATA_OMP: return GTXT("OpenMP Profiling");
67 case DATA_OMP2: return GTXT("OpenMP Profiling");
68 case DATA_OMP3: return GTXT("OpenMP Profiling");
69 case DATA_OMP4: return GTXT("OpenMP Profiling");
70 case DATA_OMP5: return GTXT("OpenMP Profiling");
71 case DATA_IOTRACE: return GTXT("IO Tracing");
73 return NTXT ("PROFDATA_TYPE_ERROR");
77 int assert_level = 0; // set to 1 to bypass problematic asserts
79 #define ASSERT_SKIP (assert_level)
85 PropDescr::PropDescr (int _propID, const char *_name)
88 name = strdup (_name ? _name : NTXT (""));
96 PropDescr::~PropDescr ()
102 stateNames->destroy ();
107 stateUNames->destroy ();
113 PropDescr::addState (int value, const char *stname, const char *stuname)
115 if (value < 0 || stname == NULL)
117 if (stateNames == NULL)
118 stateNames = new Vector<char*>;
119 stateNames->store (value, strdup (stname));
120 if (stateUNames == NULL)
121 stateUNames = new Vector<char*>;
122 stateUNames->store (value, strdup (stuname));
126 PropDescr::getStateName (int value)
128 if (stateNames && value >= 0 && value < stateNames->size ())
129 return stateNames->fetch (value);
134 PropDescr::getStateUName (int value)
136 if (stateUNames && value >= 0 && value < stateUNames->size ())
137 return stateUNames->fetch (value);
145 FieldDescr::FieldDescr (int _propID, const char *_name)
148 name = _name ? strdup (_name) : NULL;
154 FieldDescr::~FieldDescr ()
161 * class PacketDescriptor
164 PacketDescriptor::PacketDescriptor (DataDescriptor *_ddscr)
167 fields = new Vector<FieldDescr*>;
170 PacketDescriptor::~PacketDescriptor ()
177 PacketDescriptor::addField (FieldDescr *fldDscr)
181 fields->append (fldDscr);
188 /* Check compatibility between Datum and Data */
190 checkCompatibility (VType_type v1, VType_type v2)
203 assert (v2 == TYPE_INT32 ||
208 assert (v2 == TYPE_INT64 ||
216 class DataINT32 : public Data
222 data = new Vector<int32_t>;
246 return data->size ();
252 return (int) data->fetch (i);
255 virtual unsigned long long
258 return (unsigned long long) data->fetch (i);
264 return (long long) data->fetch (i);
270 return dbe_sprintf (NTXT ("%d"), data->fetch (i));
276 return (double) data->fetch (i);
282 assert (ASSERT_SKIP);
287 setDatumValue (long idx, const Datum *val)
289 data->store (idx, val->i);
293 setValue (long idx, uint64_t val)
295 data->store (idx, (int32_t) val);
299 setObjValue (long, void*)
301 assert (ASSERT_SKIP);
306 cmpValues (long idx1, long idx2)
308 int32_t i1 = data->fetch (idx1);
309 int32_t i2 = data->fetch (idx2);
310 return i1 < i2 ? -1 : i1 > i2 ? 1 : 0;
314 cmpDatumValue (long idx, const Datum *val)
316 int32_t i1 = data->fetch (idx);
318 return i1 < i2 ? -1 : i1 > i2 ? 1 : 0;
322 Vector<int32_t> *data;
325 class DataUINT32 : public Data
331 data = new Vector<uint32_t>;
355 return data->size ();
361 return (int) data->fetch (i);
364 virtual unsigned long long
367 return (unsigned long long) data->fetch (i);
373 return (long long) data->fetch (i);
379 return dbe_sprintf (NTXT ("%u"), data->fetch (i));
385 return (double) data->fetch (i);
391 assert (ASSERT_SKIP);
396 setDatumValue (long idx, const Datum *val)
398 data->store (idx, val->i);
402 setValue (long idx, uint64_t val)
404 data->store (idx, (uint32_t) val);
408 setObjValue (long, void*)
410 assert (ASSERT_SKIP);
415 cmpValues (long idx1, long idx2)
417 uint32_t u1 = data->fetch (idx1);
418 uint32_t u2 = data->fetch (idx2);
419 return u1 < u2 ? -1 : u1 > u2 ? 1 : 0;
423 cmpDatumValue (long idx, const Datum *val)
425 uint32_t u1 = data->fetch (idx);
426 uint32_t u2 = (uint32_t) val->i;
427 return u1 < u2 ? -1 : u1 > u2 ? 1 : 0;
431 Vector<uint32_t> *data;
434 class DataINT64 : public Data
440 data = new Vector<int64_t>;
464 return data->size ();
470 return (int) data->fetch (i);
473 virtual unsigned long long
476 return (unsigned long long) data->fetch (i);
482 return (long long) data->fetch (i);
488 return dbe_sprintf (NTXT ("%lld"), (long long) data->fetch (i));
494 return (double) data->fetch (i);
500 assert (ASSERT_SKIP);
505 setDatumValue (long idx, const Datum *val)
507 data->store (idx, val->ll);
511 setValue (long idx, uint64_t val)
513 data->store (idx, (int64_t) val);
517 setObjValue (long, void*)
519 assert (ASSERT_SKIP);
524 cmpValues (long idx1, long idx2)
526 int64_t i1 = data->fetch (idx1);
527 int64_t i2 = data->fetch (idx2);
528 return i1 < i2 ? -1 : i1 > i2 ? 1 : 0;
532 cmpDatumValue (long idx, const Datum *val)
534 int64_t i1 = data->fetch (idx);
535 int64_t i2 = val->ll;
536 return i1 < i2 ? -1 : i1 > i2 ? 1 : 0;
540 Vector<int64_t> *data;
543 class DataUINT64 : public Data
549 data = new Vector<uint64_t>;
573 return data->size ();
579 return (int) data->fetch (i);
582 virtual unsigned long long
585 return (unsigned long long) data->fetch (i);
591 return (long long) data->fetch (i);
597 return dbe_sprintf (NTXT ("%llu"), (long long) data->fetch (i));
603 return (double) data->fetch (i);
609 assert (ASSERT_SKIP);
614 setDatumValue (long idx, const Datum *val)
616 data->store (idx, val->ll);
620 setValue (long idx, uint64_t val)
622 data->store (idx, val);
626 setObjValue (long, void*)
628 assert (ASSERT_SKIP);
633 cmpValues (long idx1, long idx2)
635 uint64_t u1 = data->fetch (idx1);
636 uint64_t u2 = data->fetch (idx2);
637 return u1 < u2 ? -1 : u1 > u2 ? 1 : 0;
641 cmpDatumValue (long idx, const Datum *val)
643 uint64_t u1 = data->fetch (idx);
644 uint64_t u2 = (uint64_t) val->ll;
645 return u1 < u2 ? -1 : u1 > u2 ? 1 : 0;
649 Vector<uint64_t> *data;
652 class DataOBJECT : public Data
659 data = new Vector<void*>;
662 DataOBJECT (VType_type _dtype)
665 data = new Vector<void*>;
689 return data->size ();
695 assert (ASSERT_SKIP);
699 virtual unsigned long long
702 assert (ASSERT_SKIP);
709 assert (ASSERT_SKIP);
716 return dbe_sprintf (NTXT ("%lu"), (unsigned long) data->fetch (i));
722 assert (ASSERT_SKIP);
729 return data->fetch (i);
733 setDatumValue (long idx, const Datum *val)
735 data->store (idx, val->p);
739 setValue (long, uint64_t)
741 assert (ASSERT_SKIP);
746 setObjValue (long idx, void *p)
748 data->store (idx, p);
752 cmpValues (long, long)
758 cmpDatumValue (long, const Datum *)
768 class DataSTRING : public Data
774 data = new Vector<char*>;
799 return data->size ();
808 virtual unsigned long long
823 return strdup (data->fetch (i));
835 return data->fetch (i);
839 setDatumValue (long idx, const Datum *val)
841 data->store (idx, val->l);
845 setValue (long, uint64_t)
851 setObjValue (long idx, void *p)
853 data->store (idx, (char*) p);
857 cmpValues (long, long)
863 cmpDatumValue (long, const Datum *)
872 class DataDOUBLE : public Data
878 data = new Vector<double>;
902 return data->size ();
908 return (int) data->fetch (i);
911 virtual unsigned long long
914 return (unsigned long long) data->fetch (i);
920 return (long long) data->fetch (i);
926 return dbe_sprintf (NTXT ("%f"), data->fetch (i));
932 return data->fetch (i);
936 setDatumValue (long idx, const Datum *val)
938 data->store (idx, val->d);
942 setValue (long idx, uint64_t val)
944 data->store (idx, (double) val);
948 setObjValue (long, void*)
960 cmpValues (long idx1, long idx2)
962 double d1 = data->fetch (idx1);
963 double d2 = data->fetch (idx2);
964 return d1 < d2 ? -1 : d1 > d2 ? 1 : 0;
968 cmpDatumValue (long idx, const Datum *val)
970 double d1 = data->fetch (idx);
972 return d1 < d2 ? -1 : d1 > d2 ? 1 : 0;
976 Vector<double> *data;
980 Data::newData (VType_type vtype)
985 return new DataINT32;
987 return new DataUINT32;
989 return new DataINT64;
991 return new DataUINT64;
993 return new DataOBJECT;
995 return new DataSTRING;
997 return new DataDOUBLE;
1004 * class DataDescriptor
1006 DataDescriptor::DataDescriptor (int _id, const char *_name, const char *_uname,
1011 name = _name ? strdup (_name) : strdup (NTXT (""));
1012 uname = _uname ? strdup (_uname) : strdup (NTXT (""));
1015 // master data, shared with reference copies:
1017 master_resolveFrameInfoDone = false;
1018 props = new Vector<PropDescr*>;
1019 data = new Vector<Data*>;
1020 setsTBR = new Vector<Vector<long long>*>;
1022 // master references point to self:
1023 ref_size = &master_size;
1024 ref_resolveFrameInfoDone = &master_resolveFrameInfoDone;
1027 DataDescriptor::DataDescriptor (int _id, const char *_name, const char *_uname,
1028 DataDescriptor* dDscr)
1032 name = _name ? strdup (_name) : strdup (NTXT (""));
1033 uname = _uname ? strdup (_uname) : strdup (NTXT (""));
1034 flags = dDscr->flags;
1036 // references point to master DataDescriptor
1037 ref_size = &dDscr->master_size;
1038 ref_resolveFrameInfoDone = &dDscr->master_resolveFrameInfoDone;
1039 props = dDscr->props;
1041 setsTBR = dDscr->setsTBR;
1043 // data that should never be accessed in reference copy
1045 master_resolveFrameInfoDone = false;
1048 DataDescriptor::~DataDescriptor ()
1058 setsTBR->destroy ();
1063 DataDescriptor::reset ()
1067 for (int i = 0; i < data->size (); i++)
1069 Data *d = data->fetch (i);
1072 Vector<long long> *set = setsTBR->fetch (i);
1080 DataDescriptor::getProp (int prop_id)
1082 for (int i = 0; i < props->size (); i++)
1084 PropDescr *propDscr = props->fetch (i);
1085 if (propDscr->propID == prop_id)
1092 DataDescriptor::getData (int prop_id)
1094 if (prop_id < 0 || prop_id >= data->size ())
1096 return data->fetch (prop_id);
1100 DataDescriptor::addProperty (PropDescr *propDscr)
1102 if (propDscr == NULL)
1104 if (propDscr->propID < 0)
1106 PropDescr *oldProp = getProp (propDscr->propID);
1107 if (oldProp != NULL)
1109 checkCompatibility (propDscr->vtype, oldProp->vtype); //YXXX depends on experiment correctness
1113 props->append (propDscr);
1114 data->store (propDscr->propID, Data::newData (propDscr->vtype));
1115 setsTBR->store (propDscr->propID, NULL);
1119 DataDescriptor::addRecord ()
1123 return master_size++;
1127 checkEntity (Vector<long long> *set, long long val)
1131 int hi = set->size () - 1;
1134 int md = (lo + hi) / 2;
1135 long long ent = set->fetch (md);
1143 set->insert (lo, val);
1147 DataDescriptor::setDatumValue (int prop_id, long idx, const Datum *val)
1149 if (idx >= *ref_size)
1151 Data *d = getData (prop_id);
1154 VType_type datum_type = val->type;
1155 VType_type data_type = d->type ();
1156 checkCompatibility (datum_type, data_type);
1157 d->setDatumValue (idx, val);
1158 Vector<long long> *set = setsTBR->fetch (prop_id);
1159 if (set != NULL)// Sets are maintained
1160 checkEntity (set, d->fetchLong (idx));
1165 DataDescriptor::setValue (int prop_id, long idx, uint64_t val)
1167 if (idx >= *ref_size)
1169 Data *d = getData (prop_id);
1172 d->setValue (idx, val);
1173 Vector<long long> *set = setsTBR->fetch (prop_id);
1174 if (set != NULL)// Sets are maintained
1175 checkEntity (set, d->fetchLong (idx));
1180 DataDescriptor::setObjValue (int prop_id, long idx, void *val)
1182 if (idx >= *ref_size)
1184 Data *d = getData (prop_id);
1186 d->setObjValue (idx, val);
1190 DataDescriptor::createView ()
1192 return new DataView (this);
1196 DataDescriptor::createImmutableView ()
1198 return new DataView (this, DataView::DV_IMMUTABLE);
1202 DataDescriptor::createExtManagedView ()
1204 return new DataView (this, DataView::DV_EXT_MANAGED);
1208 DataDescriptor::getIntValue (int prop_id, long idx)
1210 Data *d = getData (prop_id);
1211 if (d == NULL || idx >= d->getSize ())
1213 return d->fetchInt (idx);
1217 DataDescriptor::getULongValue (int prop_id, long idx)
1219 Data *d = getData (prop_id);
1220 if (d == NULL || idx >= d->getSize ())
1222 return d->fetchULong (idx);
1226 DataDescriptor::getLongValue (int prop_id, long idx)
1228 Data *d = getData (prop_id);
1229 if (d == NULL || idx >= d->getSize ())
1231 return d->fetchLong (idx);
1235 DataDescriptor::getObjValue (int prop_id, long idx)
1237 Data *d = getData (prop_id);
1238 if (d == NULL || idx >= d->getSize ())
1240 return d->fetchObject (idx);
1244 pcmp (const void *p1, const void *p2, const void *arg)
1246 long idx1 = *(long*) p1; // index1 into Data
1247 long idx2 = *(long*) p2; // index2 into Data
1248 for (Data **dsorted = (Data**) arg; *dsorted != DATA_SORT_EOL; dsorted++)
1250 Data *data = *dsorted;
1251 if (data == NULL)// sort property not in this data, skip this criteria
1253 int res = data->cmpValues (idx1, idx2);
1257 // Provide stable sort
1258 return idx1 < idx2 ? -1 : idx1 > idx2 ? 1 : 0;
1262 DataDescriptor::getSet (int prop_id)
1264 if (prop_id < 0 || prop_id >= setsTBR->size ())
1266 Vector<long long> *set = setsTBR->fetch (prop_id);
1270 Data *d = getData (prop_id);
1273 set = new Vector<long long>;
1274 for (long i = 0; i<*ref_size; ++i)
1275 checkEntity (set, d->fetchLong (i));
1276 setsTBR->store (prop_id, set);
1284 DataView::DataView (DataDescriptor *_ddscr)
1286 init (_ddscr, DV_NORMAL);
1289 DataView::DataView (DataDescriptor *_ddscr, DataViewType _type)
1291 init (_ddscr, _type);
1295 DataView::init (DataDescriptor *_ddscr, DataViewType _type)
1302 ddsize = ddscr->getSize ();
1306 case DV_EXT_MANAGED:
1308 index = new Vector<long>;
1311 for (int ii = 0; ii < (MAX_SORT_DIMENSIONS + 1); ii++)
1312 sortedBy[ii] = DATA_SORT_EOL;
1316 DataView::~DataView ()
1323 DataView::appendDataDescriptorId (long pkt_id /* ddscr index */)
1325 if (type != DV_EXT_MANAGED)
1326 return; // updates allowed only on externally managed DataViews
1327 long curr_ddsize = ddscr->getSize ();
1328 if (pkt_id < 0 || pkt_id >= curr_ddsize)
1330 index->append (pkt_id);
1334 DataView::setDataDescriptorValue (int prop_id, long pkt_id, uint64_t val)
1336 ddscr->setValue (prop_id, pkt_id, val);
1340 DataView::getDataDescriptorValue (int prop_id, long pkt_id)
1342 return ddscr->getLongValue (prop_id, pkt_id);
1346 DataView::getProps ()
1348 return ddscr->getProps ();
1352 DataView::getProp (int prop_id)
1354 return ddscr->getProp (prop_id);
1358 DataView::filter_in_chunks (fltr_dbe_ctx *dctx)
1360 Expression::Context *e_ctx = new Expression::Context (dctx->fltr->ctx->dbev, dctx->fltr->ctx->exp);
1361 Expression *n_expr = dctx->fltr->expr->copy ();
1362 bool noParFilter = dctx->fltr->noParFilter;
1363 FilterExp *nFilter = new FilterExp (n_expr, e_ctx, noParFilter);
1364 long iter = dctx->begin;
1365 long end = dctx->end;
1366 long orig_ddsize = dctx->orig_ddsize;
1369 nFilter->put (dctx->tmpView, iter);
1370 if (nFilter->passes ())
1371 dctx->idxArr[iter - orig_ddsize] = 1;
1378 DataView::checkUpdate ()
1380 long newSize = ddscr->getSize ();
1381 if (ddsize == newSize)
1385 if (type == DV_EXT_MANAGED)
1387 bool updated = false;
1390 DataView *tmpView = ddscr->createImmutableView ();
1391 assert (tmpView->getSize () == newSize);
1392 while (ddsize < newSize)
1394 filter->put (tmpView, ddsize);
1395 if (filter->passes ())
1396 index->append (ddsize);
1402 while (ddsize < newSize)
1404 index->append (ddsize);
1412 DataView::getSize ()
1414 if (checkUpdate () && sortedBy[0] != DATA_SORT_EOL)
1415 // note: after new filter is set, getSize() incurs cost of
1416 // sorting even if caller isn't interested in sort
1417 index->sort ((CompareFunc) pcmp, sortedBy);
1420 return ddscr->getSize ();
1421 return index->size ();
1425 DataView::setDatumValue (int prop_id, long idx, const Datum *val)
1427 ddscr->setDatumValue (prop_id, getIdByIdx (idx), val);
1431 DataView::setValue (int prop_id, long idx, uint64_t val)
1433 ddscr->setValue (prop_id, getIdByIdx (idx), val);
1437 DataView::setObjValue (int prop_id, long idx, void *val)
1439 ddscr->setObjValue (prop_id, getIdByIdx (idx), val);
1443 DataView::getIntValue (int prop_id, long idx)
1445 return ddscr->getIntValue (prop_id, getIdByIdx (idx));
1449 DataView::getULongValue (int prop_id, long idx)
1451 return ddscr->getULongValue (prop_id, getIdByIdx (idx));
1455 DataView::getLongValue (int prop_id, long idx)
1457 return ddscr->getLongValue (prop_id, getIdByIdx (idx));
1461 DataView::getObjValue (int prop_id, long idx)
1463 return ddscr->getObjValue (prop_id, getIdByIdx (idx));
1467 DataView::sort (const int props[], int prop_count)
1471 assert (ASSERT_SKIP);
1474 assert (prop_count >= 0 && prop_count < MAX_SORT_DIMENSIONS);
1475 bool sort_changed = false; // see if sort has changed...
1476 for (int ii = 0; ii <= prop_count; ii++)
1477 { // sortedBy size is prop_count+1
1479 if (ii == prop_count)
1480 data = DATA_SORT_EOL; // special end of array marker
1482 data = ddscr->getData (props[ii]);
1483 if (sortedBy[ii] != data)
1485 sortedBy[ii] = data;
1486 sort_changed = true;
1489 if (!checkUpdate () && !sort_changed)
1491 index->sort ((CompareFunc) pcmp, sortedBy);
1495 DataView::sort (int prop0)
1501 DataView::sort (int prop0, int prop1)
1503 int props[2] = {prop0, prop1};
1508 DataView::sort (int prop0, int prop1, int prop2)
1510 int props[3] = {prop0, prop1, prop2};
1515 DataView::setFilter (FilterExp *f)
1519 assert (ASSERT_SKIP);
1530 DataView::getIdByIdx (long idx)
1534 return index->fetch (idx);
1538 tvalcmp (long data_id, const Datum valColumns[], Data *sortedBy[])
1540 for (int ii = 0; ii < MAX_SORT_DIMENSIONS; ii++)
1542 if (sortedBy[ii] == DATA_SORT_EOL)
1544 Data *d = sortedBy[ii];
1545 if (d == NULL)// property doesn't exist in data; compare always matches
1547 const Datum *tvalue = &valColumns[ii];
1548 int res = d->cmpDatumValue (data_id, tvalue);
1556 checkSortTypes (const Datum valColumns[], Data *sortedBy[])
1559 for (int ii = 0; ii < MAX_SORT_DIMENSIONS; ii++)
1561 if (sortedBy[ii] == DATA_SORT_EOL)
1563 Data *d = sortedBy[ii];
1564 if (d == NULL)// property doesn't exist in data; compare always matches
1566 VType_type datum_type = valColumns[ii].type;
1567 VType_type data_type = d->type ();
1568 checkCompatibility (datum_type, data_type);
1574 DataView::idxRootDimensionsMatch (long idx, const Datum valColumns[])
1576 // compares idx vs. valColumns[] - If all dimensions match
1577 // (except sort leaf), then the leaf value is valid => return true.
1578 // Otherwise, return false.
1579 checkSortTypes (valColumns, sortedBy);
1580 if (idx < 0 || idx >= index->size ()) // fell off end of array
1582 long data_id = index->fetch (idx);
1584 // we will check all dimensions for a match except the "leaf" dimension
1585 for (int ii = 0; ii < (MAX_SORT_DIMENSIONS - 1); ii++)
1587 if (sortedBy[ii + 1] == DATA_SORT_EOL)
1588 break; // we are at leaf dimension, don't care about it's value
1589 if (sortedBy[ii] == DATA_SORT_EOL)
1590 break; // end of list
1591 Data *d = sortedBy[ii];
1592 if (d == NULL) // property doesn't exist in data; compare always matches
1594 const Datum *tvalue = &valColumns[ii];
1595 int res = d->cmpDatumValue (data_id, tvalue);
1603 DataView::getIdxByVals (const Datum valColumns[], Relation rel)
1605 // checks sortedBy[] columns for match; relation only used on last column
1606 return getIdxByVals (valColumns, rel, -1, -1);
1610 DataView::getIdxByVals (const Datum valColumns[], Relation rel,
1611 long minIdx, long maxIdx)
1613 // checks sortedBy[] columns for match; relation only used on last column
1614 checkSortTypes (valColumns, sortedBy);
1615 if (index == NULL || sortedBy[0] == DATA_SORT_EOL)
1625 if (maxIdx < 0 || maxIdx >= index->size ())
1626 hi = index->size () - 1;
1634 int cmp = tvalcmp (index->fetch (md), valColumns, sortedBy);
1646 // cmp == 0, we have an exact match
1650 hi = md - 1; // continue searching
1653 lo = md + 1; // continue searching
1658 // note: "md" may not be deterministic if multiple matches exist
1659 return md; // a match => done.
1663 // no exact match found
1677 if (idxRootDimensionsMatch (md, valColumns))
1683 DataView::removeDbeViewIdx (long idx)
1685 index->remove (idx);