OmniSciDB  a5dc49c757
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Static Public Attributes | Package Functions | Private Member Functions | Private Attributes | List of all members
org.apache.calcite.rel.externalize.HeavyDBRelJson Class Reference
+ Collaboration diagram for org.apache.calcite.rel.externalize.HeavyDBRelJson:

Public Member Functions

 HeavyDBRelJson (JsonBuilder jsonBuilder)
 
RelNode create (Map< String, Object > map)
 
Constructor getConstructor (String type)
 
Class typeNameToClass (String type)
 
String classToTypeName (Class<?extends RelNode > class_)
 
Object toJson (RelCollationImpl node)
 
Object toJson (RexFieldCollation node)
 
RelCollation toCollation (List< Map< String, Object >> jsonFieldCollations)
 
RelFieldCollation toFieldCollation (Map< String, Object > map)
 
RelDistribution toDistribution (Object o)
 
RelDataType toType (RelDataTypeFactory typeFactory, Object o)
 
Object toJson (AggregateCall node)
 

Static Public Attributes

static final List< String > PACKAGES
 

Package Functions

Object toJson (Object value)
 
RexNode toRex (RelInput relInput, Object o)
 
SqlOperator toOp (RelInput relInput, String name)
 
SqlAggFunction toAggregation (String agg)
 
SqlAggFunction toAggregation (RelInput relInput, String agg)
 

Private Member Functions

Object toJson (RelDataType node)
 
Object toJson (RelDataTypeField node)
 
Object toJson (CorrelationId node)
 
Object toJson (final RexWindowBound window_bound)
 
Object toJson (RexNode node)
 
List< RexNode > toRexList (RelInput relInput, List operands)
 
SqlOperator toOp (String op)
 
SqlOperator toOp (String op, Map< String, Object > map)
 
String toJson (SqlOperator operator)
 

Private Attributes

final Map< String, Constructor > constructorMap
 
final JsonBuilder jsonBuilder
 

Detailed Description

Utilities for converting org.apache.calcite.rel.RelNode into JSON format.

Definition at line 80 of file HeavyDBRelJson.java.

Constructor & Destructor Documentation

org.apache.calcite.rel.externalize.HeavyDBRelJson.HeavyDBRelJson ( JsonBuilder  jsonBuilder)
inline

Definition at line 92 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.jsonBuilder.

92  {
93  this.jsonBuilder = jsonBuilder;
94  }

Member Function Documentation

String org.apache.calcite.rel.externalize.HeavyDBRelJson.classToTypeName ( Class<?extends RelNode >  class_)
inline

Inverse of typeNameToClass.

Definition at line 152 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.PACKAGES.

152  {
153  final String canonicalName = class_.getName();
154  for (String package_ : PACKAGES) {
155  if (canonicalName.startsWith(package_)) {
156  String remaining = canonicalName.substring(package_.length());
157  if (remaining.indexOf('.') < 0 && remaining.indexOf('$') < 0) {
158  return remaining;
159  }
160  }
161  }
162  return canonicalName;
163  }
RelNode org.apache.calcite.rel.externalize.HeavyDBRelJson.create ( Map< String, Object >  map)
inline

Definition at line 96 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.getConstructor(), and run_benchmark_import.type.

96  {
97  String type = (String) map.get("type");
98  Constructor constructor = getConstructor(type);
99  try {
100  return (RelNode) constructor.newInstance(map);
101  } catch (InstantiationException e) {
102  throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
103  } catch (IllegalAccessException e) {
104  throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
105  } catch (InvocationTargetException e) {
106  throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
107  } catch (ClassCastException e) {
108  throw new RuntimeException("while invoking constructor for type '" + type + "'", e);
109  }
110  }
run_benchmark_import.type
type
Definition: run_benchmark_import.py:89

+ Here is the call graph for this function:

Constructor org.apache.calcite.rel.externalize.HeavyDBRelJson.getConstructor ( String  type)
inline

Definition at line 112 of file HeavyDBRelJson.java.

References run_benchmark_import.type, and org.apache.calcite.rel.externalize.HeavyDBRelJson.typeNameToClass().

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.create().

112  {
113  Constructor constructor = constructorMap.get(type);
114  if (constructor == null) {
115  Class clazz = typeNameToClass(type);
116  try {
117  // noinspection unchecked
118  constructor = clazz.getConstructor(RelInput.class);
119  } catch (NoSuchMethodException e) {
120  throw new RuntimeException(
121  "class does not have required constructor, " + clazz + "(RelInput)");
122  }
123  constructorMap.put(type, constructor);
124  }
125  return constructor;
126  }
run_benchmark_import.type
type
Definition: run_benchmark_import.py:89

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

SqlAggFunction org.apache.calcite.rel.externalize.HeavyDBRelJson.toAggregation ( String  agg)
inlinepackage

Definition at line 579 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp().

579  {
580  return (SqlAggFunction) toOp(agg);
581  }

+ Here is the call graph for this function:

SqlAggFunction org.apache.calcite.rel.externalize.HeavyDBRelJson.toAggregation ( RelInput  relInput,
String  agg 
)
inlinepackage

Definition at line 583 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp().

583  {
584  return (SqlAggFunction) toOp(relInput, agg);
585  }

+ Here is the call graph for this function:

RelCollation org.apache.calcite.rel.externalize.HeavyDBRelJson.toCollation ( List< Map< String, Object >>  jsonFieldCollations)
inline

Definition at line 185 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toFieldCollation().

185  {
186  final List<RelFieldCollation> fieldCollations = new ArrayList<RelFieldCollation>();
187  for (Map<String, Object> map : jsonFieldCollations) {
188  fieldCollations.add(toFieldCollation(map));
189  }
190  return RelCollations.of(fieldCollations);
191  }
org.apache.calcite.rel.externalize.HeavyDBRelJson.toFieldCollation
RelFieldCollation toFieldCollation(Map< String, Object > map)
Definition: HeavyDBRelJson.java:193

+ Here is the call graph for this function:

RelDistribution org.apache.calcite.rel.externalize.HeavyDBRelJson.toDistribution ( Object  o)
inline

Definition at line 202 of file HeavyDBRelJson.java.

202  {
203  return RelDistributions.ANY; // TODO:
204  }
RelFieldCollation org.apache.calcite.rel.externalize.HeavyDBRelJson.toFieldCollation ( Map< String, Object >  map)
inline

Definition at line 193 of file HeavyDBRelJson.java.

References field(), and Integer.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toCollation().

193  {
194  final Integer field = (Integer) map.get("field");
195  final RelFieldCollation.Direction direction = Util.enumVal(
196  RelFieldCollation.Direction.class, (String) map.get("direction"));
197  final RelFieldCollation.NullDirection nullDirection = Util.enumVal(
198  RelFieldCollation.NullDirection.class, (String) map.get("nulls"));
199  return new RelFieldCollation(field, direction, nullDirection);
200  }
field
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:33
ExpressionRangeType::Integer

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RelCollationImpl  node)
inline

Definition at line 165 of file HeavyDBRelJson.java.

References setup.name.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

165  {
166  final List<Object> list = new ArrayList<Object>();
167  for (RelFieldCollation fieldCollation : node.getFieldCollations()) {
168  final Map<String, Object> map = jsonBuilder.map();
169  map.put("field", fieldCollation.getFieldIndex());
170  map.put("direction", fieldCollation.getDirection().name());
171  map.put("nulls", fieldCollation.nullDirection.name());
172  list.add(map);
173  }
174  return list;
175  }
setup.name
string name
Definition: setup.in.py:72

+ Here is the caller graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RexFieldCollation  node)
inline

Definition at line 177 of file HeavyDBRelJson.java.

References setup.name, and org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

177  {
178  final Map<String, Object> map = jsonBuilder.map();
179  map.put("field", toJson(node.left));
180  map.put("direction", node.getDirection().name());
181  map.put("nulls", node.getNullDirection().name());
182  return map;
183  }
setup.name
string name
Definition: setup.in.py:72

+ Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( AggregateCall  node)
inline

Definition at line 234 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

234  {
235  final Map<String, Object> map = jsonBuilder.map();
236  map.put("agg", toJson(node.getAggregation()));
237  map.put("type", toJson(node.getType()));
238  map.put("distinct", node.isDistinct());
239  map.put("operands", node.getArgList());
240  return map;
241  }

+ Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( Object  value)
inlinepackage

Definition at line 243 of file HeavyDBRelJson.java.

References Integer, and org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

243  {
244  if (value == null || value instanceof Number || value instanceof String
245  || value instanceof Boolean) {
246  return value;
247  } else if (value instanceof RexNode) {
248  return toJson((RexNode) value);
249  } else if (value instanceof CorrelationId) {
250  return toJson((CorrelationId) value);
251  } else if (value instanceof List) {
252  final List<Object> list = jsonBuilder.list();
253  for (Object o : (List) value) {
254  list.add(toJson(o));
255  }
256  return list;
257  } else if (value instanceof ImmutableBitSet) {
258  final List<Object> list = jsonBuilder.list();
259  for (Integer integer : (ImmutableBitSet) value) {
260  list.add(toJson(integer));
261  }
262  return list;
263  } else if (value instanceof AggregateCall) {
264  return toJson((AggregateCall) value);
265  } else if (value instanceof RelCollationImpl) {
266  return toJson((RelCollationImpl) value);
267  } else if (value instanceof RexFieldCollation) {
268  return toJson((RexFieldCollation) value);
269  } else if (value instanceof RelDataType) {
270  return toJson((RelDataType) value);
271  } else if (value instanceof RelDataTypeField) {
272  return toJson((RelDataTypeField) value);
273  } else if (value instanceof JoinType) {
274  return value.toString();
275  } else if (value instanceof Operation) {
276  return value.toString();
277  } else {
278  if (value.toString().contains("$cor")) {
279  throw new UnsupportedOperationException(
280  "Unable to decorrelate one of the correlated subqueries.");
281  }
282  throw new UnsupportedOperationException("type not serializable: " + value
283  + " (type " + value.getClass().getCanonicalName() + ")");
284  }
285  }
JoinType
JoinType
Definition: sqldefs.h:238
ExpressionRangeType::Integer

+ Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RelDataType  node)
inlineprivate

Definition at line 287 of file HeavyDBRelJson.java.

References field(), setup.name, and org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

287  {
288  if (node.isStruct()) {
289  final List<Object> list = jsonBuilder.list();
290  for (RelDataTypeField field : node.getFieldList()) {
291  list.add(toJson(field));
292  }
293  return list;
294  } else {
295  final Map<String, Object> map = jsonBuilder.map();
296  map.put("type", node.getSqlTypeName().name());
297  map.put("nullable", node.isNullable());
298  if (node.getSqlTypeName().allowsPrec()) {
299  map.put("precision", node.getPrecision());
300  }
301  if (node.getSqlTypeName().allowsScale()) {
302  map.put("scale", node.getScale());
303  }
304  return map;
305  }
306  }
field
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:33
setup.name
string name
Definition: setup.in.py:72

+ Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RelDataTypeField  node)
inlineprivate

Definition at line 308 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

308  {
309  final Map<String, Object> map = (Map<String, Object>) toJson(node.getType());
310  map.put("name", node.getName());
311  return map;
312  }

+ Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( CorrelationId  node)
inlineprivate

Definition at line 314 of file HeavyDBRelJson.java.

314  {
315  return node.getId();
316  }
Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( final RexWindowBound  window_bound)
inlineprivate

Definition at line 318 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson().

318  {
319  final Map<String, Object> map = jsonBuilder.map();
320  map.put("unbounded", toJson(window_bound.isUnbounded()));
321  map.put("preceding", toJson(window_bound.isPreceding()));
322  map.put("following", toJson(window_bound.isFollowing()));
323  map.put("is_current_row", toJson(window_bound.isCurrentRow()));
324  map.put("offset",
325  window_bound.getOffset() != null ? toJson(window_bound.getOffset()) : null);
326  map.put("order_key", toJson(window_bound.getOrderKey()));
327  return map;
328  }

+ Here is the call graph for this function:

Object org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( RexNode  node)
inlineprivate

Definition at line 330 of file HeavyDBRelJson.java.

References gpu_enabled.lower_bound(), setup.name, org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson(), and gpu_enabled.upper_bound().

330  {
331  final Map<String, Object> map;
332  switch (node.getKind()) {
333  case FIELD_ACCESS:
334  map = jsonBuilder.map();
335  final RexFieldAccess fieldAccess = (RexFieldAccess) node;
336  map.put("field", fieldAccess.getField().getName());
337  map.put("expr", toJson(fieldAccess.getReferenceExpr()));
338  return map;
339  case LITERAL:
340  final RexLiteral literal = (RexLiteral) node;
341  final Object value2 = literal.getValue2();
342  map = jsonBuilder.map();
343  if (value2 instanceof TimeUnitRange || value2 instanceof SqlTrimFunction.Flag) {
344  map.put("literal", value2.toString());
345  } else {
346  map.put("literal", value2);
347  }
348  map.put("type", literal.getTypeName().name());
349  map.put("target_type", literal.getType().getSqlTypeName().toString());
350  final Object value = literal.getValue();
351  if (value instanceof BigDecimal) {
352  map.put("scale", ((BigDecimal) value).scale());
353  map.put("precision", ((BigDecimal) value).precision());
354  } else {
355  map.put("scale", literal.getType().getScale());
356  map.put("precision", literal.getType().getPrecision());
357  }
358  map.put("type_scale", literal.getType().getScale());
359  map.put("type_precision", literal.getType().getPrecision());
360  return map;
361  case INPUT_REF:
362  map = jsonBuilder.map();
363  map.put("input", ((RexInputRef) node).getIndex());
364  return map;
365  case CORREL_VARIABLE:
366  map = jsonBuilder.map();
367  map.put("correl", ((RexCorrelVariable) node).getName());
368  map.put("type", toJson(node.getType()));
369  return map;
370  default:
371  if (node instanceof RexCall) {
372  final RexCall call = (RexCall) node;
373  map = jsonBuilder.map();
374  map.put("op", toJson(call.getOperator()));
375  final List<Object> list = jsonBuilder.list();
376  for (RexNode operand : call.getOperands()) {
377  list.add(toJson(operand));
378  }
379  map.put("operands", list);
380  map.put("type", toJson(node.getType()));
381  if (node instanceof RexSubQuery) {
382  final HeavyDBRelJsonWriter subqueryWriter = new HeavyDBRelJsonWriter();
383  ((RexSubQuery) node).rel.explain(subqueryWriter);
384  map.put("subquery", subqueryWriter.asJsonMap());
385  }
386  if (node instanceof RexOver) {
387  final RexWindow window = ((RexOver) node).getWindow();
388  final List<Object> partitionKeyList = jsonBuilder.list();
389  for (final RexNode partitionKey : window.partitionKeys) {
390  partitionKeyList.add(toJson(partitionKey));
391  }
392  map.put("partition_keys", partitionKeyList);
393  final List<Object> orderKeyList = jsonBuilder.list();
394  for (final RexFieldCollation orderKey : window.orderKeys) {
395  orderKeyList.add(toJson(orderKey));
396  }
397  map.put("order_keys", orderKeyList);
398  RexWindowBound lower_bound = window.getLowerBound();
399  RexWindowBound upper_bound = window.getUpperBound();
400  map.put("lower_bound", toJson(lower_bound));
401  map.put("upper_bound", toJson(upper_bound));
402  map.put("is_rows", toJson(window.isRows()));
403  }
404  if (call.getOperator() instanceof SqlFunction) {
405  switch (((SqlFunction) call.getOperator()).getFunctionType()) {
406  case USER_DEFINED_CONSTRUCTOR:
407  case USER_DEFINED_FUNCTION:
408  case USER_DEFINED_PROCEDURE:
409  case USER_DEFINED_SPECIFIC_FUNCTION:
410  map.put("class", call.getOperator().getClass().getName());
411  }
412  }
413  return map;
414  }
415  throw new UnsupportedOperationException("unknown rex " + node);
416  }
417  }
gpu_enabled::upper_bound
DEVICE auto upper_bound(ARGS &&...args)
Definition: gpu_enabled.h:123
gpu_enabled::lower_bound
DEVICE auto lower_bound(ARGS &&...args)
Definition: gpu_enabled.h:78
setup.name
string name
Definition: setup.in.py:72

+ Here is the call graph for this function:

String org.apache.calcite.rel.externalize.HeavyDBRelJson.toJson ( SqlOperator  operator)
inlineprivate

Definition at line 587 of file HeavyDBRelJson.java.

587  {
588  // User-defined operators are not yet handled.
589  return operator.getName();
590  }
SqlOperator org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp ( String  op)
inlineprivate

Definition at line 527 of file HeavyDBRelJson.java.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toAggregation(), and org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

527  {
528  return toOp(op, new HashMap<>());
529  }

+ Here is the caller graph for this function:

SqlOperator org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp ( String  op,
Map< String, Object >  map 
)
inlineprivate

Definition at line 531 of file HeavyDBRelJson.java.

531  {
532  // TODO: build a map, for more efficient lookup
533  // TODO: look up based on SqlKind
534  HeavyDBSqlOperatorTable operatorTable =
535  new HeavyDBSqlOperatorTable(SqlStdOperatorTable.instance());
536  operatorTable.addUDF(null);
537  final List<SqlOperator> operatorList = operatorTable.getOperatorList();
538  for (SqlOperator operator : operatorList) {
539  if (operator.getName().equals(op)) {
540  return operator;
541  }
542  }
543  String class_ = (String) map.get("class");
544  if (class_ != null) {
545  try {
546  return (SqlOperator) Class.forName(class_).newInstance();
547  } catch (InstantiationException e) {
548  throw new RuntimeException(e);
549  } catch (IllegalAccessException e) {
550  throw new RuntimeException(e);
551  } catch (ClassNotFoundException e) {
552  throw new RuntimeException(e);
553  }
554  }
555  throw new RuntimeException("Operator " + op + " does not supported");
556  }
SqlOperator org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp ( RelInput  relInput,
String  name 
)
inlinepackage

Definition at line 558 of file HeavyDBRelJson.java.

References setup.name.

558  {
559  // in case different operator has the same kind, check with both name and kind.
560  String kind = name;
561  String syntax = "FUNCTION";
562  SqlKind sqlKind = SqlKind.valueOf(kind);
563  SqlSyntax sqlSyntax = SqlSyntax.valueOf(syntax);
564  HeavyDBSqlOperatorTable operatorTable =
565  new HeavyDBSqlOperatorTable(SqlStdOperatorTable.instance());
566  operatorTable.addUDF(null);
567  final List<SqlOperator> operators = operatorTable.getOperatorList();
568  List<String> names = new ArrayList<>();
569  for (SqlOperator operator : operators) {
570  names.add(operator.toString());
571  if (operator.getName().equals(name)) {
572  return operator;
573  }
574  }
575  throw new RuntimeException("Aggregation function with name " + name
576  + " not found, search in " + names.toString());
577  }
setup.name
string name
Definition: setup.in.py:72
RexNode org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex ( RelInput  relInput,
Object  o 
)
inlinepackage

Definition at line 419 of file HeavyDBRelJson.java.

References Double, field(), Float, Integer, org.apache.calcite.rel.externalize.HeavyDBRelJson.toOp(), org.apache.calcite.rel.externalize.HeavyDBRelJson.toRexList(), org.apache.calcite.rel.externalize.HeavyDBRelJson.toType(), and run_benchmark_import.type.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJsonReader.readRel(), and org.apache.calcite.rel.externalize.HeavyDBRelJson.toRexList().

419  {
420  final RelOptCluster cluster = relInput.getCluster();
421  final RexBuilder rexBuilder = cluster.getRexBuilder();
422  if (o == null) {
423  return null;
424  } else if (o instanceof Map) {
425  Map map = (Map) o;
426  final String op = (String) map.get("op");
427  if (op != null) {
428  final List operands = (List) map.get("operands");
429  final Object jsonType = map.get("type");
430  final SqlOperator operator = toOp(op, map);
431  final List<RexNode> rexOperands = toRexList(relInput, operands);
432  RelDataType type;
433  if (jsonType != null) {
434  type = toType(cluster.getTypeFactory(), jsonType);
435  } else {
436  type = rexBuilder.deriveReturnType(operator, rexOperands);
437  }
438  return rexBuilder.makeCall(type, operator, rexOperands);
439  }
440  final Integer input = (Integer) map.get("input");
441  if (input != null) {
442  List<RelNode> inputNodes = relInput.getInputs();
443  int i = input;
444  for (RelNode inputNode : inputNodes) {
445  final RelDataType rowType = inputNode.getRowType();
446  if (i < rowType.getFieldCount()) {
447  final RelDataTypeField field = rowType.getFieldList().get(i);
448  return rexBuilder.makeInputRef(field.getType(), input);
449  }
450  i -= rowType.getFieldCount();
451  }
452  throw new RuntimeException("input field " + input + " is out of range");
453  }
454  final String field = (String) map.get("field");
455  if (field != null) {
456  final Object jsonExpr = map.get("expr");
457  final RexNode expr = toRex(relInput, jsonExpr);
458  return rexBuilder.makeFieldAccess(expr, field, true);
459  }
460  final String correl = (String) map.get("correl");
461  if (correl != null) {
462  final Object jsonType = map.get("type");
463  RelDataType type = toType(cluster.getTypeFactory(), jsonType);
464  return rexBuilder.makeCorrel(type, new CorrelationId(correl));
465  }
466  if (map.containsKey("literal")) {
467  final Object literal = map.get("literal");
468  final SqlTypeName sqlTypeName =
469  Util.enumVal(SqlTypeName.class, (String) map.get("type"));
470  if (literal == null) {
471  return rexBuilder.makeNullLiteral(
472  cluster.getTypeFactory().createSqlType(sqlTypeName));
473  }
474 
475  // HEAVY.AI serializes numeric literals differently, we need more data
476  // then the number. So, we need to have a special case for that.
477  if (literal instanceof Number) {
478  final SqlTypeName targetTypeName =
479  Util.enumVal(SqlTypeName.class, (String) map.get("target_type"));
480  final long scale = ((Number) map.get("scale")).longValue();
481  final long precision = ((Number) map.get("precision")).longValue();
482  final long typeScale = ((Number) map.get("type_scale")).longValue();
483  final long typePrecision = ((Number) map.get("type_precision")).longValue();
484  RelDataTypeFactory typeFactory = cluster.getTypeFactory();
485 
486  BigDecimal value =
487  BigDecimal.valueOf(((Number) literal).longValue(), (int) scale);
488 
489  if (typeScale != 0 && typeScale != -2147483648) {
490  return rexBuilder.makeLiteral(value,
491  typeFactory.createSqlType(
492  SqlTypeName.DECIMAL, (int) typePrecision, (int) typeScale),
493  false);
494  } else {
495  return rexBuilder.makeLiteral(
496  value, typeFactory.createSqlType(targetTypeName), false);
497  }
498  } else {
499  return toRex(relInput, literal);
500  }
501  }
502  throw new UnsupportedOperationException("cannot convert to rex " + o);
503  } else if (o instanceof Boolean) {
504  return rexBuilder.makeLiteral((Boolean) o);
505  } else if (o instanceof String) {
506  return rexBuilder.makeLiteral((String) o);
507  } else if (o instanceof Number) {
508  final Number number = (Number) o;
509  if (number instanceof Double || number instanceof Float) {
510  return rexBuilder.makeApproxLiteral(BigDecimal.valueOf(number.doubleValue()));
511  } else {
512  return rexBuilder.makeExactLiteral(BigDecimal.valueOf(number.longValue()));
513  }
514  } else {
515  throw new UnsupportedOperationException("cannot convert to rex " + o);
516  }
517  }
ExpressionRangeType::Double
org.apache.calcite.rel.externalize.HeavyDBRelJson.toRexList
List< RexNode > toRexList(RelInput relInput, List operands)
Definition: HeavyDBRelJson.java:519
field
const rapidjson::Value & field(const rapidjson::Value &obj, const char field[]) noexcept
Definition: JsonAccessors.h:33
org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex
RexNode toRex(RelInput relInput, Object o)
Definition: HeavyDBRelJson.java:419
org.apache.calcite.rel.externalize.HeavyDBRelJson.toType
RelDataType toType(RelDataTypeFactory typeFactory, Object o)
Definition: HeavyDBRelJson.java:206
ExpressionRangeType::Integer
ExpressionRangeType::Float
run_benchmark_import.type
type
Definition: run_benchmark_import.py:89

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

List<RexNode> org.apache.calcite.rel.externalize.HeavyDBRelJson.toRexList ( RelInput  relInput,
List  operands 
)
inlineprivate

Definition at line 519 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

519  {
520  final List<RexNode> list = new ArrayList<RexNode>();
521  for (Object operand : operands) {
522  list.add(toRex(relInput, operand));
523  }
524  return list;
525  }
org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex
RexNode toRex(RelInput relInput, Object o)
Definition: HeavyDBRelJson.java:419

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

RelDataType org.apache.calcite.rel.externalize.HeavyDBRelJson.toType ( RelDataTypeFactory  typeFactory,
Object  o 
)
inline

Definition at line 206 of file HeavyDBRelJson.java.

References Integer, and run_benchmark_import.type.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.toRex().

206  {
207  if (o instanceof List) {
208  @SuppressWarnings("unchecked")
209  final List<Map<String, Object>> jsonList = (List<Map<String, Object>>) o;
210  final RelDataTypeFactory.Builder builder = typeFactory.builder();
211  for (Map<String, Object> jsonMap : jsonList) {
212  builder.add((String) jsonMap.get("name"), toType(typeFactory, jsonMap));
213  }
214  return builder.build();
215  } else {
216  final Map<String, Object> map = (Map<String, Object>) o;
217  final SqlTypeName sqlTypeName =
218  Util.enumVal(SqlTypeName.class, (String) map.get("type"));
219  final Integer precision = (Integer) map.get("precision");
220  final Integer scale = (Integer) map.get("scale");
221  final RelDataType type;
222  if (precision == null) {
223  type = typeFactory.createSqlType(sqlTypeName);
224  } else if (scale == null) {
225  type = typeFactory.createSqlType(sqlTypeName, precision);
226  } else {
227  type = typeFactory.createSqlType(sqlTypeName, precision, scale);
228  }
229  final boolean nullable = (Boolean) map.get("nullable");
230  return typeFactory.createTypeWithNullability(type, nullable);
231  }
232  }
org.apache.calcite.rel.externalize.HeavyDBRelJson.toType
RelDataType toType(RelDataTypeFactory typeFactory, Object o)
Definition: HeavyDBRelJson.java:206
ExpressionRangeType::Integer
run_benchmark_import.type
type
Definition: run_benchmark_import.py:89

+ Here is the caller graph for this function:

Class org.apache.calcite.rel.externalize.HeavyDBRelJson.typeNameToClass ( String  type)
inline

Converts a type name to a class. E.g.

getClass("LogicalProject")

returns org.apache.calcite.rel.logical.LogicalProject.class.

Definition at line 132 of file HeavyDBRelJson.java.

References org.apache.calcite.rel.externalize.HeavyDBRelJson.PACKAGES, and run_benchmark_import.type.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.getConstructor().

132  {
133  if (!type.contains(".")) {
134  for (String package_ : PACKAGES) {
135  try {
136  return Class.forName(package_ + type);
137  } catch (ClassNotFoundException e) {
138  // ignore
139  }
140  }
141  }
142  try {
143  return Class.forName(type);
144  } catch (ClassNotFoundException e) {
145  throw new RuntimeException("unknown type " + type);
146  }
147  }
run_benchmark_import.type
type
Definition: run_benchmark_import.py:89

+ Here is the caller graph for this function:

Member Data Documentation

final Map<String, Constructor> org.apache.calcite.rel.externalize.HeavyDBRelJson.constructorMap
private
Initial value:
=
new HashMap<String, Constructor>()

Definition at line 81 of file HeavyDBRelJson.java.

final JsonBuilder org.apache.calcite.rel.externalize.HeavyDBRelJson.jsonBuilder
private

Definition at line 83 of file HeavyDBRelJson.java.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.HeavyDBRelJson().

final List<String> org.apache.calcite.rel.externalize.HeavyDBRelJson.PACKAGES
static
Initial value:
= ImmutableList.of("org.apache.calcite.rel.",
"org.apache.calcite.rel.core.",
"org.apache.calcite.rel.logical.",
"org.apache.calcite.adapter.jdbc.",
"org.apache.calcite.adapter.enumerable.",
"org.apache.calcite.adapter.jdbc.JdbcRules$")

Definition at line 85 of file HeavyDBRelJson.java.

Referenced by org.apache.calcite.rel.externalize.HeavyDBRelJson.classToTypeName(), and org.apache.calcite.rel.externalize.HeavyDBRelJson.typeNameToClass().

The documentation for this class was generated from the following file: