} // _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)); }