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> OperatorGetAll(Oper odb, Dictionary <long, byte[]> cache, ReadOptions ro)
{
var result_set = new List <int>();
using (var it = leveld_db.NewIterator(null, ro))
{
var key = MakeIndexSearchKey(new IndexKeyInfo()
{
ColumnNumber = odb.ColumnNumber,
TableNumber = odb.TableNumber,
Val = PostNullConstantPreEverythingElse,
ColumnType = odb.ColumnType
});
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);
}
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);
}
result_set.Add(kinfo.Id);
//PutToCache(kinfo, cache);
}
}
}
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);
}
Oper FillOpData(Expression expr, List <ParameterExpression> pars, Type table_type)
{
var table_info = GetTableInfo(table_type.Name);
var pname = pars.First().Name;
if (expr.NodeType == ExpressionType.Convert && !expr.ToString().StartsWith(pname))
{
throw new LinqDbException("Linqdb: Error in Where statement, probably type mismatch, for example int and int? are different types and both side of an expression must be of same type. Cast the right hand side's value.");
}
var column_name = SharedUtils.GetPropertyName(expr.ToString());
var op = new Oper()
{
Type = expr.NodeType,
ColumnName = column_name,
TableName = table_info.Name,
IsOperator = false,
IsDb = true,
TableNumber = table_info.TableNumber,
ColumnNumber = table_info.ColumnNumbers[column_name],
ColumnType = table_info.Columns[column_name]
};
return(op);
}
public List <int> FindOneBetween(BetweenInfo bet, Dictionary <long, byte[]> cache, ReadOptions ro)
{
var result = new List <int>();
var skey = MakeSnapshotKey(bet.TableNumber, bet.ColumnNumber);
var snapid = leveld_db.Get(skey, null, ro);
string snapshot_id = null;
string id_snapshot_id = null;
if (snapid != null)
{
snapshot_id = Encoding.UTF8.GetString(snapid);
skey = MakeSnapshotKey(bet.TableNumber, bet.IdNumber);
snapid = leveld_db.Get(skey, null, ro);
id_snapshot_id = Encoding.UTF8.GetString(snapid);
if (indexes.ContainsKey(bet.TableName + "|" + bet.ColumnName + "|" + snapshot_id))
{
var op = new Oper()
{
ColumnNumber = bet.ColumnNumber,
ColumnType = bet.ColumnType,
TableNumber = bet.TableNumber,
ColumnName = bet.ColumnName,
TableName = bet.TableName
};
var val = EncodeValue(op.ColumnType, bet.From);
var index_res = GreaterThanOperatorWithIndex(op, val, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromInclusiveToExclusive, ro, snapshot_id, id_snapshot_id, bet.To, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromExclusiveToInclusive);
return(index_res);
}
}
if (bet.From >= 0 && bet.To >= 0)
{
var op = new Oper()
{
ColumnNumber = bet.ColumnNumber,
ColumnType = bet.ColumnType,
TableNumber = bet.TableNumber,
ColumnName = bet.ColumnName,
TableName = bet.TableName
};
var val = EncodeValue(op.ColumnType, bet.From);
var result_tmp = GreaterThanOperator(op, val, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromInclusiveToExclusive, cache, ro, snapshot_id, id_snapshot_id,
bet.To, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromExclusiveToInclusive);
result = result_tmp;
}
else if (bet.From < 0 && bet.To < 0)
{
var op = new Oper()
{
ColumnNumber = (short)(-1 * bet.ColumnNumber),
ColumnType = bet.ColumnType,
TableNumber = bet.TableNumber,
TableName = bet.TableName,
ColumnName = bet.ColumnName
};
var val = EncodeValue(op.ColumnType, bet.To);
if (val.Type == LinqDbTypes.double_)
{
val.DoubleVal *= -1;
}
else if (val.Type == LinqDbTypes.int_)
{
val.IntVal *= -1;
}
var result_tmp = GreaterThanOperator(op, val, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromExclusiveToInclusive, cache, ro, snapshot_id, id_snapshot_id,
-1 * bet.From, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromInclusiveToExclusive);
result = result_tmp;
}
else
{
var op = new Oper()
{
ColumnNumber = (short)(-1 * bet.ColumnNumber),
ColumnType = bet.ColumnType,
TableNumber = bet.TableNumber,
TableName = bet.TableName,
ColumnName = bet.ColumnName
};
var val = EncodeValue(op.ColumnType, 0);
var result_tmp = GreaterThanOperator(op, val, true, cache, ro, snapshot_id, id_snapshot_id,
-1 * bet.From, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromInclusiveToExclusive);
result = result_tmp;
op = new Oper()
{
ColumnNumber = bet.ColumnNumber,
ColumnType = bet.ColumnType,
TableNumber = bet.TableNumber,
TableName = bet.TableName,
ColumnName = bet.ColumnName
};
val = EncodeValue(op.ColumnType, 0);
var result_pos = GreaterThanOperator(op, val, false, cache, ro, snapshot_id, id_snapshot_id,
bet.To, bet.BetweenBoundaries == BetweenBoundariesInternal.BothInclusive || bet.BetweenBoundaries == BetweenBoundariesInternal.FromExclusiveToInclusive);
result = result.MyUnion(result_pos);
}
return(result);
}
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);
}
public void ParseBinExpr(BinaryExpression expr, List <ParameterExpression> pars, Stack <Oper> stack, Type table_type)
{
var op = new Oper()
{
IsOperator = true,
Type = expr.NodeType
};
stack.Push(op);
var left = expr.Left;
var right = expr.Right;
if (left is BinaryExpression)
{
ParseBinExpr(left as BinaryExpression, pars, stack, table_type);
}
else
{
op = FillOpData(left, pars, table_type);
stack.Push(op);
}
if (right is BinaryExpression)
{
ParseBinExpr(right as BinaryExpression, pars, stack, table_type);
}
else
{
try
{
object tmp_val = null;
if (right is MemberExpression || right.NodeType == ExpressionType.Convert && (right as UnaryExpression).Operand is MemberExpression)
{
MemberExpression outerMember = null;
if (right is MemberExpression)
{
outerMember = (MemberExpression)right;
}
else
{
outerMember = (right as UnaryExpression).Operand as MemberExpression;
}
if (outerMember.Member is FieldInfo)
{
FieldInfo outerProp = (FieldInfo)outerMember.Member;
if (outerMember is MemberExpression && outerMember.Member is FieldInfo && (outerMember.Member as FieldInfo).IsStatic)
{
object source = null;
tmp_val = ((FieldInfo)outerMember.Member).GetValue(source);
}
else if (outerMember.Expression is MemberExpression)
{
MemberExpression innerMember = (MemberExpression)outerMember.Expression;
FieldInfo innerField = (FieldInfo)innerMember.Member;
ConstantExpression ce = (ConstantExpression)innerMember.Expression;
object innerObj = ce.Value;
object outerObj = innerField.GetValue(innerObj);
tmp_val = outerProp.GetValue(outerObj);
}
else if (outerMember.Expression is ConstantExpression)
{
var constantSelector = (ConstantExpression)outerMember.Expression;
tmp_val = ((FieldInfo)outerMember.Member).GetValue(constantSelector.Value);
}
else
{
throw new Exception("bad where");
}
}
else if (outerMember.Member is PropertyInfo)
{
PropertyInfo outerProp = (PropertyInfo)outerMember.Member;
if (outerMember.Expression is ConstantExpression)
{
tmp_val = (outerMember.Member as PropertyInfo).GetValue(((ConstantExpression)outerMember.Expression).Value);
}
else
{
MemberExpression innerMember = (MemberExpression)outerMember.Expression;
FieldInfo innerField = (FieldInfo)innerMember.Member;
ConstantExpression ce = (ConstantExpression)innerMember.Expression;
object innerObj = ce.Value;
object outerObj = innerField.GetValue(innerObj);
tmp_val = outerProp.GetValue(outerObj, null);
}
}
else
{
throw new Exception("bad where");
}
}
else if (right.NodeType == ExpressionType.Convert)
{
var operand = (right as UnaryExpression).Operand;
if (operand is ConstantExpression)
{
tmp_val = (operand as ConstantExpression).Value;
}
else
{
operand = (operand as UnaryExpression).Operand;
tmp_val = (operand as ConstantExpression).Value;
}
}
else if (right.NodeType == ExpressionType.Constant)
{
tmp_val = (right as ConstantExpression).Value;
}
else
{
throw new Exception("bad where");
}
if (right.NodeType == ExpressionType.MemberAccess || right.NodeType == ExpressionType.Constant || right.NodeType == ExpressionType.Convert)
{
op = new Oper()
{
IsDb = false,
IsOperator = false,
NonDbValue = tmp_val
};
stack.Push(op);
return;
}
else
{
throw new Exception("bad where");
}
//op = FillOpData(right, pars, table_type);
//stack.Push(op);
}
catch (Exception ex)
{
throw new LinqDbException("Linqdb: error in Where clause - on the right hand side of the operator there must be member access (first level) or variable or constant of the same type as left hand side.");
}
}
}
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);
}
}
}
}
public Tuple <List <int>, bool> GetIds <T>(QueryTree tree)
{
if ((tree.BetweenInfo == null || !tree.BetweenInfo.Any()) &&
(tree.IntersectInfo == null || !tree.IntersectInfo.Any()) &&
(tree.SearchInfo == null || !tree.SearchInfo.Any()) &&
(tree.WhereInfo == null || !tree.WhereInfo.Any()))
{
//.Where(f => f.Id > 0)
CheckTableInfo <T>();
var table_info = GetTableInfo(typeof(T).Name);
var op1 = new Oper()
{
ColumnName = null,
ColumnNumber = 0,
ColumnType = LinqDbTypes.int_,
IsDb = false,
IsOperator = true,
IsResult = false,
NonDbValue = null,
Result = null,
TableName = table_info.Name,
TableNumber = table_info.TableNumber,
Type = System.Linq.Expressions.ExpressionType.GreaterThan
};
var op2 = new Oper()
{
ColumnName = "Id",
ColumnNumber = table_info.ColumnNumbers["Id"],
ColumnType = LinqDbTypes.int_,
IsDb = true,
IsOperator = false,
IsResult = false,
NonDbValue = null,
Result = null,
TableName = table_info.Name,
TableNumber = table_info.TableNumber,
Type = System.Linq.Expressions.ExpressionType.MemberAccess
};
var op3 = new Oper()
{
ColumnName = null,
ColumnNumber = 0,
ColumnType = LinqDbTypes.int_,
IsDb = false,
IsOperator = false,
IsResult = false,
NonDbValue = 0,
Result = null
};
tree.WhereInfo = new List <WhereInfo>();
tree.WhereInfo.Add(new WhereInfo()
{
Id = 1,
Opers = new Stack <Oper>()
});
tree.WhereInfo[0].Opers.Push(op1);
tree.WhereInfo[0].Opers.Push(op2);
tree.WhereInfo[0].Opers.Push(op3);
}
CheckTableInfo <T>();
using (var snapshot = leveld_db.CreateSnapshot())
{
var ro = new ReadOptions().SetSnapshot(snapshot);
var table_info = GetTableInfo(typeof(T).Name);
var where_res = CalculateWhereResult <T>(tree, table_info, ro);
where_res = FindBetween(tree, where_res, ro);
where_res = Intersect(tree, where_res, table_info, tree.QueryCache, ro);
double?searchPercentile = null;
where_res = Search(tree, where_res, ro, out searchPercentile);
var fres = CombineData(where_res);
var total = GetTableRowCount(table_info, ro);
var all = total == fres.ResIds.Count();
return(new Tuple <List <int>, bool>(fres.ResIds.ToList(), all));
}
}
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> IntersectWithIndex(Oper odb, List <EncodedValue> val, ReadOptions ro, string snapshot_id, string id_snapshot_id)
{
var 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);
}
int bloom_max = 1000000;
switch (odb.ColumnType)
{
case LinqDbTypes.int_:
HashSet <int> ivals = new HashSet <int>(val.Where(f => !f.IsNull).Select(f => f.IntVal));
List <bool> bloom_int = new List <bool>(bloom_max);
for (int i = 0; i < bloom_max; i++)
{
bloom_int.Add(false);
}
foreach (var int_val in ivals)
{
bloom_int[int_val % bloom_max] = true;
}
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++)
{
int id = ids[j];
if (bloom_int[iv[j] % bloom_max])
{
if (ivals.Contains(iv[j]))
{
result.Add(id);
}
}
}
}
break;
case LinqDbTypes.double_:
case LinqDbTypes.DateTime_:
HashSet <double> dvals = new HashSet <double>(val.Where(f => !f.IsNull).Select(f => f.DoubleVal));
List <bool> bloom_double = new List <bool>(bloom_max);
for (int i = 0; i < bloom_max; i++)
{
bloom_double.Add(false);
}
foreach (var d_val in dvals)
{
bloom_double[Math.Abs(d_val.GetHashCode()) % bloom_max] = true;
}
int dcount = index.Parts.Count();
for (int i = 0; i < dcount; 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++)
{
int id = ids[j];
if (bloom_double[Math.Abs(iv[j].GetHashCode()) % bloom_max])
{
if (dvals.Contains(iv[j]))
{
result.Add(id);
}
}
}
}
break;
default:
return(null);
}
return(result);
}
public List <int> IntersectOne(IntersectInfo info, TableInfo table_info, Dictionary <long, byte[]> cache, ReadOptions ro)
{
var result = new List <int>();
//if (info.Set.Count() > 50)
//{
Oper odb = new Oper()
{
TableNumber = info.TableNumber,
ColumnType = info.ColumnType,
ColumnNumber = info.ColumnNumber,
ColumnName = table_info.ColumnNumbers.First(f => f.Value == info.ColumnNumber).Key,
TableName = table_info.Name
};
var skey = MakeSnapshotKey(table_info.TableNumber, table_info.ColumnNumbers[odb.ColumnName]);
var snapid = leveld_db.Get(skey, null, ro);
if (snapid != null)
{
var snapshot_id = Encoding.UTF8.GetString(snapid);
skey = MakeSnapshotKey(table_info.TableNumber, table_info.ColumnNumbers["Id"]);
snapid = leveld_db.Get(skey, null, ro);
string id_snapshot_id = Encoding.UTF8.GetString(snapid);
var index_res = IntersectWithIndex(odb, info.Set, ro, snapshot_id, id_snapshot_id);
if (index_res != null)
{
return(index_res);
}
}
foreach (var val in info.Set)
{
Oper odb2 = new Oper()
{
TableNumber = info.TableNumber,
ColumnType = info.ColumnType,
ColumnNumber = info.ColumnNumber,
ColumnName = table_info.ColumnNumbers.First(f => f.Value == info.ColumnNumber).Key,
TableName = table_info.Name
};
result.AddRange(EqualOperator(odb2, val, table_info, cache, ro, null, null));
}
return(result);
//}
//foreach (var val in info.Set)
//{
// Oper odb = new Oper()
// {
// TableNumber = info.TableNumber,
// ColumnType = info.ColumnType,
// ColumnNumber = info.ColumnNumber,
// ColumnName = table_info.ColumnNumbers.First(f => f.Value == info.ColumnNumber).Key,
// TableName = table_info.Name
// };
// result.AddRange(EqualOperator(odb, val, table_info, cache, ro, null, null));
//}
//return result;
}
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);
}
}
