private void CheckDecode()
{
if (!decoded)
{
if (EncodedValue == null)
{
value = null;
}
else
{
var v = EncodedValue.DecodeAsString();
if (v.Length == 0)
{
value = null;
}
else if (typeof(T) == typeof(string))
{
value = v as T;
}
else
{
value = JsonConvert.DeserializeObject <T>(v);
}
}
decoded = true;
}
}
List <int> GreaterThanNegativeOperator(Oper odb, EncodedValue val, bool is_equal, Dictionary <long, byte[]> cache, ReadOptions ro, string snapshot_id, string id_snapshot_id)
{
if (!string.IsNullOrEmpty(snapshot_id))
{
if (indexes.ContainsKey(odb.TableName + "|" + odb.ColumnName + "|" + snapshot_id))
{
return(new List <int>());
}
}
var result_set = new List <int>();
if (val.Type == LinqDbTypes.double_ && val.DoubleVal >= 0 || val.Type == LinqDbTypes.DateTime_ && val.DoubleVal >= 0 || val.Type == LinqDbTypes.int_ && val.IntVal >= 0)
{
return(result_set);
}
else
{
if (val.Type == LinqDbTypes.double_)
{
val.DoubleVal *= -1;
}
if (val.Type == LinqDbTypes.int_)
{
val.IntVal *= -1;
}
return(LessThanOperator(odb, val, is_equal, cache, ro, snapshot_id, id_snapshot_id));
}
}
List <int> NotEqualOperator(Oper odb, EncodedValue val, Dictionary <long, byte[]> cache, ReadOptions ro, string snapshot_id, string id_snapshot_id)
{
var index_res = NotEqualOperatorWithIndex(odb, val, ro, snapshot_id, id_snapshot_id);
if (index_res != null)
{
return(index_res);
}
var r = NotEqualGeneric(odb, val, cache, ro);
if (val.IsNull)
{
return(r);
}
//negative
if (val.IsNull)
{
odb.ColumnNumber *= -1;
var rn = OperatorGetAll(odb, cache, ro);
r = r.MyUnion(rn);
}
else if (odb.ColumnType == LinqDbTypes.double_ || odb.ColumnType == LinqDbTypes.DateTime_)
{
if (val.DoubleVal < 0)
{
odb.ColumnNumber *= -1;
val.DoubleVal = -1 * val.DoubleVal;
}
var rn = NotEqualGeneric(odb, val, cache, ro);
r = r.MyUnion(rn);
}
else if (odb.ColumnType == LinqDbTypes.int_)
{
if (val.IntVal < 0)
{
odb.ColumnNumber *= -1;
val.IntVal = -1 * val.IntVal;
}
var rn = NotEqualGeneric(odb, val, cache, ro);
r = r.MyUnion(rn);
}
else if (odb.ColumnType == LinqDbTypes.string_)
{
var rn = NotEqualGeneric(odb, val, cache, ro);
r = r.MyUnion(rn);
}
return(r);
}
List <int> NotEqualGeneric(Oper odb, EncodedValue val, Dictionary <long, byte[]> cache, ReadOptions ro)
{
byte[] byte_val = null;
if (val.IsNull)
{
byte_val = NullConstant;
}
else if (odb.ColumnType == LinqDbTypes.double_ || odb.ColumnType == LinqDbTypes.DateTime_)
{
byte_val = BitConverter.GetBytes(val.DoubleVal).MyReverseNoCopy();
}
else if ((odb.ColumnType == LinqDbTypes.int_))
{
byte_val = BitConverter.GetBytes(val.IntVal).MyReverseNoCopy();
}
else if ((odb.ColumnType == LinqDbTypes.string_))
{
byte_val = val.StringValue;
}
var result_set = new List <int>();
var key = MakeIndexSearchKey(new IndexKeyInfo()
{
ColumnNumber = odb.ColumnNumber,
TableNumber = odb.TableNumber,
Val = PreNull,
ColumnType = odb.ColumnType
});
using (var it = leveld_db.NewIterator(null, ro))
{
it.Seek(key);
if (!it.Valid())
{
return(result_set);
}
var v = it.Key();
if (v == null)
{
return(result_set);
}
var kinfo = GetIndexKey(v);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (!ValsEqual(kinfo.Val, byte_val))
{
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
}
while (true)
{
it.Next();
if (!it.Valid())
{
return(result_set);
}
var ckey = it.Key();
if (ckey == null)
{
return(result_set);
}
kinfo = GetIndexKey(ckey);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (!ValsEqual(kinfo.Val, byte_val))
{
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
}
else
{
continue;
}
}
}
}
List <int> NotEqualOperatorWithIndex(Oper odb, EncodedValue val, ReadOptions ro, string snapshot_id, string id_snapshot_id)
{
List <int> result = new List <int>();
if (string.IsNullOrEmpty(snapshot_id))
{
return(null);
}
if (string.IsNullOrEmpty(odb.TableName) || string.IsNullOrEmpty(odb.ColumnName))
{
throw new LinqDbException("Linqdb: bad indexes.");
}
if (!indexes.ContainsKey(odb.TableName + "|" + odb.ColumnName + "|" + snapshot_id))
{
return(null);
}
var index = indexes[odb.TableName + "|" + odb.ColumnName + "|" + snapshot_id];
var ids_index = indexes[odb.TableName + "|Id|" + id_snapshot_id];
if (index.IndexType == IndexType.GroupOnly)
{
return(null);
}
switch (odb.ColumnType)
{
case LinqDbTypes.int_:
if (val.IsNull)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (iv[j] != null)
{
result.Add((int)ids[j]);
}
}
}
}
else
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (iv[j] != val.IntVal)
{
result.Add((int)ids[j]);
}
}
}
}
break;
case LinqDbTypes.double_:
case LinqDbTypes.DateTime_:
if (val.IsNull)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (iv[j] != null)
{
result.Add((int)ids[j]);
}
}
}
}
else
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (iv[j] != val.DoubleVal)
{
result.Add((int)ids[j]);
}
}
}
}
break;
default:
return(null);
}
return(result);
}
private object ConvertField(EncodedValue value, Class currentClass)
{
switch (value.EncodedType)
{
case EncodedValueType.VALUE_BYTE:
return(((EncodedNumber)value).AsByte());
case EncodedValueType.VALUE_NULL:
return(null);
case EncodedValueType.VALUE_BOOLEAN:
return(((EncodedNumber)value).AsBoolean());
case EncodedValueType.VALUE_SHORT:
return(((EncodedNumber)value).AsShort());
case EncodedValueType.VALUE_CHAR:
return(((EncodedNumber)value).AsChar());
case EncodedValueType.VALUE_INT:
return(((EncodedNumber)value).AsInt());
case EncodedValueType.VALUE_LONG:
return(((EncodedNumber)value).AsLong());
case EncodedValueType.VALUE_FLOAT:
return(((EncodedNumber)value).AsFloat());
case EncodedValueType.VALUE_DOUBLE:
return(((EncodedNumber)value).AsDouble());
case EncodedValueType.VALUE_STRING:
return(String.Format("\"{0}\"", runningApp.dex.GetString(((EncodedNumber)value).AsId()).Replace("\n", "\\n")));
case EncodedValueType.VALUE_TYPE:
return(runningApp.dex.GetTypeName(((EncodedNumber)value).AsId()));
case EncodedValueType.VALUE_FIELD:
case EncodedValueType.VALUE_ENUM:
return(edw.GetFieldName(((EncodedNumber)value).AsId(), currentClass, true));
case EncodedValueType.VALUE_METHOD:
return(runningApp.dex.GetMethod(((EncodedNumber)value).AsId()));
//return string.Format("{0}.{1}", runningApp.dex.GetTypeName(method.ClassIndex), method.Name);
case EncodedValueType.VALUE_ARRAY:
var encodedArray = (EncodedArray)value;
object[] array = new object[(int)encodedArray.Count];
int i = 0;
foreach (var arrayValue in encodedArray.GetValues())
{
//array.Add(ConvertField(arrayValue, currentClass));
array[i] = ConvertField(arrayValue, currentClass);
i++;
}
return(array);
//return string.Format("[{0}]", string.Join(",", array));
case EncodedValueType.VALUE_ANNOTATION:
//Not sure when/if this is used
var stringAnnotation = new StringWriter();
edw.AnnotationToString(stringAnnotation, (EncodedAnnotation)value, currentClass, new Indentation());
return(stringAnnotation);
}
return("Unknown");
}
List <int> GreaterThanOperatorWithIndex(Oper odb, EncodedValue val, bool is_equal, ReadOptions ro, string snapshot_id, string id_snapshot_id, double?stop_val = null, bool stop_equal = false)
{
List <int> result = new List <int>();
if (string.IsNullOrEmpty(snapshot_id))
{
return(null);
}
if (string.IsNullOrEmpty(odb.TableName) || string.IsNullOrEmpty(odb.ColumnName))
{
throw new LinqDbException("Linqdb: bad indexes.");
}
if (!indexes.ContainsKey(odb.TableName + "|" + odb.ColumnName + "|" + snapshot_id))
{
return(null);
}
var index = indexes[odb.TableName + "|" + odb.ColumnName + "|" + snapshot_id];
var ids_index = indexes[odb.TableName + "|Id|" + id_snapshot_id];
if (index.IndexType == IndexType.GroupOnly)
{
return(null);
}
switch (odb.ColumnType)
{
case LinqDbTypes.int_:
if (val.IsNull)
{
throw new LinqDbException("Linqdb: can't evaluate < null");
}
else
{
int ival = val.IntVal;
if (!is_equal && stop_val == null)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (ival < iv[j])
{
result.Add((int)ids[j]);
}
}
}
}
else if (is_equal && stop_val == null)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (ival <= iv[j])
{
result.Add((int)ids[j]);
}
}
}
}
else if (!is_equal && stop_val != null)
{
int stop_val_int = (int)stop_val;
if (!stop_equal)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (ival < iv[j] && iv[j] < stop_val_int)
{
result.Add((int)ids[j]);
}
}
}
}
else
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (ival < iv[j] && iv[j] <= stop_val_int)
{
result.Add((int)ids[j]);
}
}
}
}
}
else if (is_equal && stop_val != null)
{
int stop_val_int = (int)stop_val;
if (!stop_equal)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (ival <= iv[j] && iv[j] < stop_val_int)
{
result.Add((int)ids[j]);
}
}
}
}
else
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].IntValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (ival <= iv[j] && iv[j] <= stop_val_int)
{
result.Add((int)ids[j]);
}
}
}
}
}
}
break;
case LinqDbTypes.double_:
case LinqDbTypes.DateTime_:
if (val.IsNull)
{
throw new LinqDbException("Linqdb: can't evaluate < null");
}
else
{
double dval = val.DoubleVal;
if (!is_equal && stop_val == null)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (dval < iv[j])
{
result.Add((int)ids[j]);
}
}
}
}
else if (is_equal && stop_val == null)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (dval <= iv[j])
{
result.Add((int)ids[j]);
}
}
}
}
else if (!is_equal && stop_val != null)
{
double stop_val_double = (double)stop_val;
if (!stop_equal)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (dval < iv[j] && iv[j] < stop_val_double)
{
result.Add((int)ids[j]);
}
}
}
}
else
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (dval < iv[j] && iv[j] <= stop_val_double)
{
result.Add((int)ids[j]);
}
}
}
}
}
else if (is_equal && stop_val != null)
{
double stop_val_double = (double)stop_val;
if (!stop_equal)
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (dval <= iv[j] && iv[j] < stop_val_double)
{
result.Add((int)ids[j]);
}
}
}
}
else
{
int icount = index.Parts.Count();
for (int i = 0; i < icount; i++)
{
var ids = ids_index.Parts[i].IntValues;
var iv = index.Parts[i].DoubleValues;
int jcount = iv.Count();
for (int j = 0; j < jcount; j++)
{
if (dval <= iv[j] && iv[j] <= stop_val_double)
{
result.Add((int)ids[j]);
}
}
}
}
}
}
break;
default:
return(null);
}
return(result);
}
List <int> GreaterThanOperator(Oper odb, EncodedValue val, bool is_equal, Dictionary <long, byte[]> cache, ReadOptions ro, string snapshot_id, string id_snapshot_id, double?stop_val = null, bool stop_equal = false)
{
var index_res = GreaterThanOperatorWithIndex(odb, val, is_equal, ro, snapshot_id, id_snapshot_id, stop_val, stop_equal);
if (index_res != null)
{
return(index_res);
}
if (val.Type == LinqDbTypes.double_ && val.DoubleVal < 0 || val.Type == LinqDbTypes.DateTime_ && val.DoubleVal < 0 || val.Type == LinqDbTypes.int_ && val.IntVal < 0)
{
return(OperatorGetAll(odb, cache, ro));
}
else
{
var result_set = new List <int>();
byte[] byte_val = null;
if (val.IsNull)
{
byte_val = NullConstant;
}
else if (odb.ColumnType == LinqDbTypes.double_ || odb.ColumnType == LinqDbTypes.DateTime_)
{
byte_val = BitConverter.GetBytes(val.DoubleVal).MyReverseNoCopy();
}
else if ((odb.ColumnType == LinqDbTypes.int_))
{
byte_val = BitConverter.GetBytes(val.IntVal).MyReverseNoCopy();
}
var key = MakeIndexSearchKey(new IndexKeyInfo()
{
ColumnNumber = odb.ColumnNumber,
TableNumber = odb.TableNumber,
Val = byte_val,
ColumnType = odb.ColumnType
});
using (var it = leveld_db.NewIterator(null, ro))
{
it.Seek(key);
if (!it.Valid())
{
return(result_set);
}
var ck = it.Key();
if (ck == null)
{
return(result_set);
}
var kinfo = GetIndexKey(ck);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (stop_val != null)
{
double cv = 0;
if (val.Type == LinqDbTypes.int_)
{
cv = BitConverter.ToInt32(kinfo.Val.MyReverseWithCopy(), 0);
}
if (val.Type == LinqDbTypes.double_ || val.Type == LinqDbTypes.DateTime_)
{
cv = BitConverter.ToDouble(kinfo.Val.MyReverseWithCopy(), 0);
}
if (cv == stop_val && !stop_equal || cv > stop_val)
{
return(result_set);
}
}
while (ValsEqual(kinfo.Val, byte_val))
{
if (is_equal)
{
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
}
it.Next();
if (!it.Valid())
{
return(result_set);
}
ck = it.Key();
if (ck == null)
{
return(result_set);
}
kinfo = GetIndexKey(ck);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
}
if (stop_val != null)
{
double cv = 0;
if (val.Type == LinqDbTypes.int_)
{
cv = BitConverter.ToInt32(kinfo.Val.MyReverseWithCopy(), 0);
}
if (val.Type == LinqDbTypes.double_ || val.Type == LinqDbTypes.DateTime_)
{
cv = BitConverter.ToDouble(kinfo.Val.MyReverseWithCopy(), 0);
}
if (cv == stop_val && !stop_equal || cv > stop_val)
{
return(result_set);
}
}
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
while (true)
{
it.Next();
if (!it.Valid())
{
return(result_set);
}
ck = it.Key();
if (ck == null)
{
return(result_set);
}
kinfo = GetIndexKey(ck);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (stop_val != null)
{
double cv = 0;
if (val.Type == LinqDbTypes.int_)
{
cv = BitConverter.ToInt32(kinfo.Val.MyReverseWithCopy(), 0);
}
if (val.Type == LinqDbTypes.double_ || val.Type == LinqDbTypes.DateTime_)
{
cv = BitConverter.ToDouble(kinfo.Val.MyReverseWithCopy(), 0);
}
if (cv == stop_val && !stop_equal || cv > stop_val)
{
return(result_set);
}
}
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
}
}
}
}
List <int> EqualOperator(Oper odb, EncodedValue val, TableInfo table_info, Dictionary <long, byte[]> cache, ReadOptions ro, string snapshot_id, string id_snapshot_id)
{
if (!string.IsNullOrEmpty(snapshot_id))
{
var index_res = EqualOperatorWithIndex(odb, val, table_info, ro, snapshot_id, id_snapshot_id);
if (index_res != null)
{
return(index_res);
}
}
byte[] byte_val = null;
if (val.IsNull)
{
byte_val = NullConstant;
}
else if (odb.ColumnType == LinqDbTypes.double_ || odb.ColumnType == LinqDbTypes.DateTime_)
{
if (val.DoubleVal < 0)
{
odb.ColumnNumber *= -1;
val.DoubleVal = -1 * val.DoubleVal;
}
byte_val = BitConverter.GetBytes(val.DoubleVal).MyReverseNoCopy();
}
else if ((odb.ColumnType == LinqDbTypes.int_))
{
if (val.IntVal < 0)
{
odb.ColumnNumber *= -1;
val.IntVal = -1 * val.IntVal;
}
byte_val = BitConverter.GetBytes(val.IntVal).MyReverseNoCopy();
}
else if (odb.ColumnType == LinqDbTypes.string_)
{
byte_val = val.StringValue;
}
var result_set = new List <int>();
var key = MakeIndexSearchKey(new IndexKeyInfo()
{
ColumnNumber = odb.ColumnNumber,
TableNumber = odb.TableNumber,
Val = byte_val,
ColumnType = odb.ColumnType
});
using (var it = leveld_db.NewIterator(null, ro))
{
it.Seek(key);
if (!it.Valid())
{
return(result_set);
}
var v = it.Key();
if (v == null)
{
return(result_set);
}
var kinfo = GetIndexKey(v);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (ValsEqual(kinfo.Val, byte_val))
{
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
while (true)
{
it.Next();
if (!it.Valid())
{
return(result_set);
}
var ckey = it.Key();
if (ckey == null)
{
return(result_set);
}
kinfo = GetIndexKey(ckey);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (ValsEqual(kinfo.Val, byte_val))
{
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
}
else
{
return(result_set);
}
}
}
return(result_set);
}
}
List <int> LessThanOperator(Oper odb, EncodedValue val, bool or_equal, Dictionary <long, byte[]> cache, ReadOptions ro, string snapshot_id, string id_snapshot_id)
{
if (!string.IsNullOrEmpty(snapshot_id))
{
var index_res = LessThanOperatorWithIndex(odb, val, or_equal, ro, snapshot_id, id_snapshot_id);
if (index_res != null)
{
return(index_res);
}
}
var result_set = new List <int>();
if (val.Type == LinqDbTypes.double_ && val.DoubleVal < 0 || val.Type == LinqDbTypes.DateTime_ && val.DoubleVal < 0 || val.Type == LinqDbTypes.int_ && val.IntVal < 0)
{
return(result_set);
}
else
{
byte[] byte_val = null;
if (val.IsNull)
{
byte_val = NullConstant;
}
else if (odb.ColumnType == LinqDbTypes.double_ || odb.ColumnType == LinqDbTypes.DateTime_)
{
byte_val = BitConverter.GetBytes(val.DoubleVal).MyReverseNoCopy();
}
else if ((odb.ColumnType == LinqDbTypes.int_))
{
byte_val = BitConverter.GetBytes(val.IntVal).MyReverseNoCopy();
}
using (var it = leveld_db.NewIterator(null, ro))
{
var pkey = MakeIndexKey(new IndexKeyInfo()
{
TableNumber = odb.TableNumber,
ColumnNumber = odb.ColumnNumber,
Val = PostNullConstantPreEverythingElse,
ColumnType = odb.ColumnType
});
it.Seek(pkey); //skip null values
if (!it.Valid())
{
return(result_set);
}
var v = it.Key();
if (v == null)
{
return(result_set);
}
var kinfo = GetIndexKey(v);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (ValGreater(byte_val, kinfo.Val) || (or_equal && ValsEqual(kinfo.Val, byte_val)))
{
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
while (true)
{
it.Next();
if (!it.Valid())
{
return(result_set);
}
var ckey = it.Key();
if (ckey == null)
{
return(result_set);
}
kinfo = GetIndexKey(ckey);
if (kinfo.NotKey || kinfo.TableNumber != odb.TableNumber || kinfo.ColumnNumber != odb.ColumnNumber)
{
return(result_set);
}
if (ValGreater(byte_val, kinfo.Val) || (or_equal && ValsEqual(kinfo.Val, byte_val)))
{
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
}
else
{
return(result_set);
}
}
}
}
return(result_set);
}
}
