@Override public DataContext getDataContext() { return _delegate.getDataContext(); }
@Override protected UsageAwareDatastoreConnection<DataContext> createDatastoreConnection() { final List<DataContext> dataContexts = new ArrayList<>(_datastores.size()); final List<Closeable> closeables = new ArrayList<>(_datastores.size()); for (final Datastore datastore : _datastores) { final DatastoreConnection con = datastore.openConnection(); final DataContext dc = con.getDataContext(); closeables.add(con); dataContexts.add(dc); } final Closeable[] closeablesArray = closeables.toArray(new Closeable[closeables.size()]); return new DatastoreConnectionImpl<>(DataContextFactory.createCompositeDataContext(dataContexts), this, closeablesArray); }
public Column[] getSynonymColumns(final DatastoreConnection datastoreConnection) { final Column[] columns = new Column[_synonymColumnPaths.length]; for (int i = 0; i < columns.length; i++) { final String columnPath = _synonymColumnPaths[i]; columns[i] = datastoreConnection.getDataContext().getColumnByQualifiedLabel(columnPath); if (columns[i] == null) { throw new NoSuchColumnException(columnPath); } } return columns; }
public Column getMasterTermColumn(final DatastoreConnection datastoreConnection) { final DataContext dataContext = datastoreConnection.getDataContext(); final Column masterTermColumn = dataContext.getColumnByQualifiedLabel(_masterTermColumnPath); if (masterTermColumn == null) { throw new NoSuchColumnException(_masterTermColumnPath); } return masterTermColumn; }
private Object[] performQuery(final InputRow row, final List<Object> queryInput) { try { final Column[] queryConditionColumns = getQueryConditionColumns(); final Object[] parameterValues = new Object[queryConditionColumns.length]; for (int i = 0; i < queryConditionColumns.length; i++) { parameterValues[i] = queryInput.get(i); } try (DataSet dataSet = datastoreConnection.getDataContext().executeQuery(lookupQuery, parameterValues)) { return handleDataSet(row, dataSet); } } catch (final RuntimeException e) { logger.error("Error occurred while looking up based on conditions: " + queryInput, e); throw e; } }
@Override public Schema createSchema() { final Neo4jDatastore datastore = createDatastore(); try (DatastoreConnection connection = datastore.openConnection()) { return connection.getDataContext().getDefaultSchema(); } }
@Override public Schema createSchema() { final HBaseDatastore datastore = createDatastore(); try (DatastoreConnection con = datastore.openConnection()) { return con.getDataContext().getDefaultSchema(); } }
@Override public Schema createSchema() { final ElasticSearchDatastore datastore = createDatastore(); try (DatastoreConnection con = datastore.openConnection()) { return con.getDataContext().getDefaultSchema(); } }
public Column getColumn(final DatastoreConnection datastoreConnection) { try { final Column column = datastoreConnection.getDataContext().getColumnByQualifiedLabel(_qualifiedColumnName); if (column == null) { throw new NoSuchColumnException(_qualifiedColumnName); } return column; } catch (final RuntimeException e) { datastoreConnection.close(); throw e; } }
@Override public Schema createSchema() { final CassandraDatastore datastore = createDatastore(); try (DatastoreConnection con = datastore.openConnection()) { return con.getDataContext().getDefaultSchema(); } }
@Override protected RowProcessingQueryOptimizer fetch() { final Datastore datastore = getAnalysisJob().getDatastore(); try (DatastoreConnection con = datastore.openConnection()) { final DataContext dataContext = con.getDataContext(); final Column[] columnArray = _physicalColumns.toArray(new Column[_physicalColumns.size()]); final Query baseQuery = dataContext.query().from(getTable()).select(columnArray).toQuery(); logger.debug("Base query for row processing: {}", baseQuery); // try to optimize return new RowProcessingQueryOptimizerImpl(datastore, getConsumersSorted(), baseQuery); } catch (final RuntimeException e) { logger.error("Failed to build query optimizer! {}", e.getMessage(), e); throw e; } } };
public List<Column> getColumns() { if (_columns == null) { try (DatastoreConnection openConnection = _jsonDatastore.openConnection()) { _columns = openConnection.getDataContext().getDefaultSchema().getTable(0).getColumns(); } } return _columns; } }
private DataSet getPreviewData(final String filename) { if (!isPreviewDataAvailable()) { logger.info("Not displaying preview table because isPreviewDataAvailable() returned false"); return null; } final D datastore = getPreviewDatastore(filename); try (DatastoreConnection con = datastore.openConnection()) { final DataContext dc = con.getDataContext(); final Table table = getPreviewTable(dc); List<Column> columns = table.getColumns(); if (columns.size() > getPreviewColumns()) { // include max 10 columns columns = columns.stream().limit(getPreviewColumns()).collect(Collectors.toList()); } final Query q = dc.query().from(table).select(columns).toQuery(); q.setMaxRows(7); return dc.executeQuery(q); } }
@Override public SchemaIdentifier getDefaultSchema(TenantIdentifier tenant, DatastoreIdentifier datastoreId) throws DatastoreConnectionException { final TenantContext tenantContext = _tenantContextFactory.getContext(tenant); final Datastore datastore = tenantContext.getDatastore(datastoreId); if (datastore == null) { return null; } try (final DatastoreConnection con = datastore.openConnection()) { final Schema schema = con.getDataContext().getDefaultSchema(); return new SchemaIdentifier(datastoreId, schema.getName()); } catch (Exception e) { logger.warn("Failed to open connection to datastore: " + datastoreId.getName(), e); throw new DatastoreConnectionException(e.getMessage()); } }
@Override public void actionPerformed(final ActionEvent event) { final String queryString = _queryTextArea.getText(); logger.debug("Query being parsed: {}", queryString); try (DatastoreConnection con = _datastore.openConnection()) { final DataContext dataContext = con.getDataContext(); final Query q = dataContext.parseQuery(queryString); logger.info("Parsed query: {}", q); final String limitString = _limitTextField.getText(); if (!StringUtils.isNullOrEmpty(limitString)) { final int limit = Integer.parseInt(limitString); q.setMaxRows(limit); } final DataSet dataSet = dataContext.executeQuery(q); _centerPanel.setVisible(true); _table.setModel(new DataSetTableModel(dataSet)); } catch (final MetaModelException e) { WidgetUtils.showErrorMessage("Failed to execute query", e.getMessage(), e); } } });
public SimpleDictionary loadIntoMemory(final DatastoreConnection datastoreConnection) { final DataContext dataContext = datastoreConnection.getDataContext(); final Column column = getColumn(datastoreConnection); final Query query = dataContext.query().from(column.getTable()).select(column).toQuery(); if (datastoreConnection.getDatastore().getPerformanceCharacteristics().isQueryOptimizationPreferred()) { query.getSelectClause().setDistinct(true); } final Set<String> values = new HashSet<>(); try (DataSet dataSet = dataContext.executeQuery(query)) { while (dataSet.next()) { final Object value = dataSet.getRow().getValue(0); if (value != null) { values.add(value.toString()); } } } return new SimpleDictionary(getName(), values); }
public SimpleSynonymCatalog loadIntoMemory(final DatastoreConnection datastoreConnection) { final Map<String, String> synonymMap = new HashMap<>(); final Column masterTermColumn = getMasterTermColumn(datastoreConnection); final Column[] columns = getSynonymColumns(datastoreConnection); try (DataSet dataSet = datastoreConnection.getDataContext().query().from(masterTermColumn.getTable().getName()) .select(masterTermColumn).select(columns).execute()) { while (dataSet.next()) { final Row row = dataSet.getRow(); final String masterTerm = getMasterTerm(row, masterTermColumn); final String[] synonyms = getSynonyms(row, columns); for (final String synonym : synonyms) { synonymMap.put(synonym, masterTerm); } } } return new SimpleSynonymCatalog(getName(), synonymMap); }
private void compileLookupQuery() { try { final Column[] queryOutputColumns = getQueryOutputColumns(false); final Column queryOutputColumn = queryOutputColumns[0]; final Table table = queryOutputColumn.getTable(); Query query = new Query().from(table).select(queryOutputColumns); if (!isCarthesianProductMode()) { final Column[] queryConditionColumns = getQueryConditionColumns(); for (int i = 0; i < queryConditionColumns.length; i++) { query = query.where(queryConditionColumns[i], OperatorType.EQUALS_TO, new QueryParameter()); } } if (joinSemantic == JoinSemantic.LEFT_JOIN_MAX_ONE) { query = query.setMaxRows(1); } lookupQuery = datastoreConnection.getDataContext().compileQuery(query); } catch (final RuntimeException e) { logger.error("Error occurred while compiling lookup query", e); throw e; } }
@Override public boolean containsValue(final String value) { final DataContext dataContext = _datastoreConnection.getDataContext(); final Column column = _dictionary.getColumn(_datastoreConnection); try (DataSet dataSet = dataContext.query().from(column.getTable()).select(column).where(column).eq(value) .maxRows(1).execute()) { if (dataSet.next()) { return true; } return false; } }
public Column resolveForeignColumn(final DatastoreCatalog datastoreCatalog) { final Datastore datastore = datastoreCatalog.getDatastore(getForeignDatastoreName()); if (datastore == null) { return null; } try (DatastoreConnection connection = datastore.openConnection()) { final DataContext dataContext = connection.getDataContext(); final Schema schema = dataContext.getSchemaByName(getForeignSchemaName()); if (schema == null) { return null; } final Table table = schema.getTableByName(getForeignTableName()); if (table == null) { return null; } return table.getColumnByName(getForeignColumnName()); } } }