} // _Number_Comparable_Impl_
//public static IComparable<object> getComparable(object o)
//{
// NNumber n = toNumber(o);
// return new _Number_Comparable_Impl_(_instance, n);
//} // getComparable()
public int Compare(object o1, object o2)
{
NNumber n1 = toNumber(o1);
NNumber n2 = toNumber(o2);
if (n1 == null && n2 == null)
{
return(0);
}
if (n1 == null)
{
return(-1);
}
if (n2 == null)
{
return(1);
}
if (n1 is NNumber && n2 is NNumber)
{
return((n1.asBigInteger()).CompareTo(n2.asBigInteger()));
}
//if (n1 is BigDecimal && n2 is BigDecimal) {
// return ((BigDecimal)n1).compareTo((BigDecimal)n2);
//}
if (NumberComparator.IsIntegerType(n1) && NumberComparator.IsIntegerType(n2))
{
return(NInteger.ValueOf(n1).CompareTo(n2.asLong()));
}
return(NNumber.ValueOf(n1).CompareTo(n2.asLong()));
} // Compare()
// @Override
public GroupedQueryBuilder lessThanOrEquals(NNumber number)
{
if (number == null)
{
throw new ArgumentException("number cannot be null");
}
return(applyFilter(new FilterItem(_selectItem, OperatorType.LESS_THAN_OR_EQUAL, number)));
}
// @Override
public GroupedQueryBuilder differentFrom(NNumber number)
{
if (number == null)
{
throw new ArgumentException("number cannot be null");
}
return(applyFilter(new FilterItem(_selectItem, OperatorType.DIFFERENT_FROM, number)));
}
// @Override
public GroupedQueryBuilder greaterThan(NNumber number)
{
if (number == null)
{
throw new ArgumentException("number cannot be null");
}
return(applyFilter(new FilterItem(_selectItem, OperatorType.GREATER_THAN, number)));
}
// @Override
public GroupedQueryBuilder isEquals(NNumber number)
{
if (number == null)
{
throw new ArgumentException("number cannot be null");
}
return(applyFilter(new FilterItem(_selectItem, OperatorType.EQUALS_TO, number)));
}
} // convertFromString()
private static NDate convertFromNumber(NNumber value)
{
NNumber numberValue = (NNumber)value;
long long_value = numberValue.asLong();
NNumber n = new NNumber(long_value);
String string_value = n.ToString();
// test if the number is actually a format of the type yyyyMMdd
if (string_value.Length == 8 && (string_value.StartsWith("1") || string_value.StartsWith("2")))
{
try
{
string format = "yyyyMMdd";
DateTimeFormatInfo dtfi = NDateUtils.createDateFormat(format);
return(new NDate(string_value, format, dtfi));
}
catch (Exception e)
{
// do nothing, proceed to next method of conversion
}
}
// test if the number is actually a format of the type yyMMdd
if (string_value.Length == 6)
{
try
{
string format = "yyMMdd";
DateTimeFormatInfo dtfi = NDateUtils.createDateFormat(format);
return(new NDate(string_value, format, dtfi));
}
#pragma warning disable 0168
catch (Exception e)
{
// do nothing, proceed to next method of conversion
}
#pragma warning restore 0168
}
if (long_value > 5000000)
{
// Java: this number is most probably amount of milliseconds since 1970
// C#: this number is most probably amount of milliseconds since 1900
NDate d = new NDate(DateTime.Now);
return(new NDate(long_value));
}
else
{
// Java: this number is most probably amount of milliseconds since 1970
// C#: this number is most probably amount of milliseconds since 1900
return(new NDate(long_value * 1000 * 60 * 60 * 24));
}
} // convertFromNumber()
static void Main()
{
NDouble d = new NDouble(3.5);
NInt i = new NInt(2);
//
// These two natural 'copy' forms fail because no covariant (polymorphic) return types
// are supported in C#.
//
// NDouble dc = d.copy();
// NInt ic = i.copy();
//
// Unlike C++, we have to downcast instead.
//
NDouble dc = (NDouble)d.copy();
NInt ic = (NInt)i.copy();
NDouble ddc = NDouble.narrow(dc);
NInt dic = NInt.narrow(ic);
dc = ddc; ic = dic; // warning suppression
virtual_poly.incr(ic);
if ((i.get() + 1) != ic.get())
{
throw new Exception("incr test failed");
}
//
// Checking a pure user downcast
//
NNumber n1 = d.copy();
NNumber n2 = d.nnumber();
NDouble dn1 = NDouble.narrow(n1);
NDouble dn2 = NDouble.narrow(n2);
if ((dn1.get()) != dn2.get())
{
throw new Exception("copy/narrow test failed");
}
//
// Checking the ref polymorphic case
//
NNumber nr = d.ref_this();
NDouble dr1 = NDouble.narrow(nr);
NDouble dr2 = (NDouble)d.ref_this();
if (dr1.get() != dr2.get())
{
throw new Exception("copy/narrow test failed");
}
}
public override sealed IObject Construct(IEnvironment environment, IArgs args)
{
var obj = new NNumber(environment);
obj.Class = "Number";
obj.Extensible = true;
obj.Prototype = environment.NumberPrototype;
if (args.Count > 0)
{
obj.PrimitiveValue = args[0].ConvertToNumber();
}
else
{
obj.PrimitiveValue = environment.CreateNumber(0.0);
}
return obj;
}
public sealed override IObject Construct(IEnvironment environment, IArgs args)
{
var obj = new NNumber(environment);
obj.Class = "Number";
obj.Extensible = true;
obj.Prototype = environment.NumberPrototype;
if (args.Count > 0)
{
obj.PrimitiveValue = args[0].ConvertToNumber();
}
else
{
obj.PrimitiveValue = environment.CreateNumber(0.0);
}
return(obj);
}
// @Override
public GroupedQueryBuilder ne(NNumber number)
{
return(differentFrom(number));
}
// @Override
public GroupedQueryBuilder eq(NNumber number)
{
return(isEquals(number));
}
public GroupedQueryBuilder lt(NNumber number)
{
return(lessThan(number));
}
// @Override
public GroupedQueryBuilder greaterThanOrEquals(NNumber number)
{
return(_filterBuilder.greaterThanOrEquals(number));
}
public override GroupedQueryBuilder equals(NNumber number)
{
throw new NotImplementedException();
}
} // Compare()
/**
* Determines if a particular number is an integer-type number such as
* {@link Byte}, {@link Short}, {@link Integer}, {@link Long},
* {@link AtomicInteger} or {@link AtomicLong}.
*
* Note that {@link BigInteger} is not included in this set of number
* classes since treatment of {@link BigInteger} requires different logic.
*
* @param n
* @return
*/
public static bool IsIntegerType(NNumber n)
{
return(n is NInteger || n is NAtomicInteger || n is NAtomicLong);
} // isIntegerType()
// @Override
public GroupedQueryBuilder isEquals(NNumber number)
{
return(_filterBuilder.isEquals(number));
}
public override GroupedQueryBuilder higherThan(NNumber number)
{
throw new NotImplementedException();
}
public abstract GroupedQueryBuilder equals(NNumber number);
public abstract GroupedQueryBuilder higherThan(NNumber number);
// @Override
public GroupedQueryBuilder gte(NNumber number)
{
return(greaterThanOrEquals(number));
}
public _Number_Comparable_Impl_(IComparer <object> instance_arg, NNumber value_arg)
{
_value_ = value_arg;
_instance_ = instance_arg;
} // constructor
} // constructor
public DataSet executeQuery(Query query)
{
List <SelectItem> selectItems = query.getSelectClause().getItems();
List <FromItem> fromItems = query.getFromClause().getItems();
List <FilterItem> whereItems = query.getWhereClause().getItems();
List <SelectItem> whereSelectItems = query.getWhereClause().getEvaluatedSelectItems();
List <GroupByItem> groupByItems = query.getGroupByClause().getItems();
List <SelectItem> groupBySelectItems = query.getGroupByClause().getEvaluatedSelectItems();
List <SelectItem> havingSelectItems = query.getHavingClause().getEvaluatedSelectItems();
List <SelectItem> orderBySelectItems = query.getOrderByClause().getEvaluatedSelectItems();
List <FilterItem> havingItems = query.getHavingClause().getItems();
List <OrderByItem> orderByItems = query.getOrderByClause().getItems();
int firstRow = (query.getFirstRow() == null ? 1 : query.getFirstRow());
int maxRows = (query.getMaxRows() == null ? -1 : query.getMaxRows());
if (maxRows == 0)
{
// no rows requested - no reason to do anything
return(new EmptyDataSet(selectItems));
}
// check certain common query types that can often be optimized by
// subclasses
bool singleFromItem = fromItems.Count == 1;
bool noGrouping = groupByItems.IsEmpty() && havingItems.IsEmpty();
if (singleFromItem && noGrouping)
{
FromItem fromItem = query.getFromClause().getItem(0);
Table table = fromItem.getTable();
if (table != null)
{
// check for SELECT COUNT(*) queries
if (selectItems.Count == 1)
{
SelectItem selectItem = query.getSelectClause().getItem(0);
if (SelectItem.isCountAllItem(selectItem))
{
bool functionApproximationAllowed = selectItem.isFunctionApproximationAllowed();
if (isMainSchemaTable(table))
{
logger.debug("Query is a COUNT query with {} where items. Trying executeCountQuery(...)",
whereItems.Count);
NNumber count = executeCountQuery(table, whereItems, functionApproximationAllowed);
if (count == null)
{
logger.debug(
"DataContext did not return any count query results. Proceeding with manual counting.");
}
else
{
List <Row> data = new List <Row>(1);
DataSetHeader header = new SimpleDataSetHeader(new SelectItem[] { selectItem });
data.Add(new DefaultRow(header, new Object[] { count }));
return(new InMemoryDataSet(header, data));
}
}
}
}
bool is_simple_select = isSimpleSelect(query.getSelectClause());
if (is_simple_select)
{
// check for lookup query by primary key
if (whereItems.Count == 1)
{
FilterItem whereItem = whereItems[0];
SelectItem selectItem = whereItem.getSelectItem();
if (!whereItem.isCompoundFilter() && selectItem != null && selectItem.getColumn() != null)
{
Column column = selectItem.getColumn();
if (column.isPrimaryKey() && OperatorType.EQUALS_TO.Equals(whereItem.getOperator()))
{
logger.debug(
"Query is a primary key lookup query. Trying executePrimaryKeyLookupQuery(...)");
if (table != null)
{
if (isMainSchemaTable(table))
{
Object operand = whereItem.getOperand();
Row row = executePrimaryKeyLookupQuery(table, selectItems, column, operand);
if (row == null)
{
logger.debug(
"DataContext did not return any GET query results. Proceeding with manual lookup.");
}
else
{
DataSetHeader header = new SimpleDataSetHeader(selectItems);
return(new InMemoryDataSet(header, row));
}
}
}
}
}
}
// check for simple queries with or without simple criteria
if (orderByItems.IsEmpty())
{
DataSet ds = null;
// no WHERE criteria set
if (whereItems.IsEmpty())
{
ds = materializeTable(table, selectItems, firstRow, maxRows);
return(ds);
}
ds = materializeTable(table, selectItems, whereItems, firstRow, maxRows);
return(ds);
}
}
}
}
// Creates a list for all select items that are needed to execute query
// (some may only be used as part of a filter, but not shown in result)
List <SelectItem> workSelectItems = CollectionUtils.concat(true, selectItems, whereSelectItems,
groupBySelectItems, havingSelectItems, orderBySelectItems);
// Materialize the tables in the from clause
DataSet[] fromDataSets = new DataSet[fromItems.Count];
for (int i = 0; i < fromDataSets.Length; i++)
{
FromItem fromItem = fromItems[i];
fromDataSets[i] = materializeFromItem(fromItem, workSelectItems);
}
// Execute the query using the raw data
DataSet dataSet = null; // MetaModelHelper.getCarthesianProduct(fromDataSets, whereItems);
// we can now exclude the select items imposed by the WHERE clause (and
// should, to make the aggregation process faster)
workSelectItems = CollectionUtils.concat(true, selectItems, groupBySelectItems, havingSelectItems,
orderBySelectItems);
if (groupByItems.Count > 0)
{
dataSet = MetaModelHelper.getGrouped(workSelectItems, dataSet, groupByItems);
}
else
{
dataSet = MetaModelHelper.getAggregated(workSelectItems, dataSet);
}
dataSet = MetaModelHelper.getFiltered(dataSet, havingItems);
if (query.getSelectClause().isDistinct())
{
dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
dataSet = MetaModelHelper.getDistinct(dataSet);
dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems);
}
else
{
dataSet = MetaModelHelper.getOrdered(dataSet, orderByItems);
dataSet = MetaModelHelper.getSelection(selectItems, dataSet);
}
dataSet = MetaModelHelper.getPaged(dataSet, firstRow, maxRows);
return(dataSet);
} // executeQuery()
} // isIntegerType()
public static NNumber toNumber(object value)
{
String string_value;
if (value == null)
{
return(null);
}
else if (value is NNumber)
{
return((NNumber)value);
}
else if (value is NBool)
{
if (bool.TrueString.Equals(value.ToString()))
{
return(NInteger.ONE);
}
else
{
return(NInteger.ZERO);
}
}
else
{
string_value = value.ToString().Trim();
if (string_value.IsEmpty())
{
return(null);
}
try
{
return(new NNumber(NNumber.ParseInt(string_value)));
}
catch (FormatException e)
{
}
try
{
return(NNumber.ParseLong(string_value));
}
catch (FormatException e)
{
}
try
{
return(new NNumber(NNumber.ParseDouble(string_value)));
}
catch (FormatException e)
{
}
}
//[J2Cs: Weird syntax block referring a variable from the previous if/else block]
// note: Boolean.parseBoolean does not throw NumberFormatException -
// it just returns false in case of invalid values.
{
if ("true".Equals(string_value, StringComparison.CurrentCultureIgnoreCase))
{
return(NInteger.ONE);
}
if ("false".Equals(string_value, StringComparison.CurrentCultureIgnoreCase))
{
return(NInteger.ZERO);
}
}
logger.warn("Could not convert '{}' to number, returning null", value);
return(null);
} // toNumber()
// @Override
public GroupedQueryBuilder lessThanOrEquals(NNumber number)
{
return(_filterBuilder.lessThanOrEquals(number));
}
// @Override
public GroupedQueryBuilder lte(NNumber number)
{
return(lessThanOrEquals(number));
}
// @Override
public GroupedQueryBuilder gt(NNumber number)
{
return(greaterThan(number));
}
public override int GetHashCode()
{
return(NNumber != null?NNumber.GetHashCode() : 0);
}
// @Override
public GroupedQueryBuilder differentFrom(NNumber number)
{
return(_filterBuilder.differentFrom(number));
}
