@Override
public void execute() throws TranslatorException {
LogManager.logTrace(
LogConstants.CTX_CONNECTOR,
"ObjectExecution command:",
query.toString(),
"using connection:",
connection.getClass().getName()); // $NON-NLS-1$ //$NON-NLS-2$
String nameInSource =
getNameInSource(((NamedTable) query.getFrom().get(0)).getMetadataObject());
List<Object> results = factory.search(query, nameInSource, connection, executionContext);
if (results != null && results.size() > 0) {
LogManager.logDetail(
LogConstants.CTX_CONNECTOR,
"ObjectExecution number of returned objects is :",
results.size()); // $NON-NLS-1$
} else {
LogManager.logDetail(
LogConstants.CTX_CONNECTOR,
"ObjectExecution number of objects returned is : 0"); //$NON-NLS-1$
results = Collections.emptyList();
}
this.resultsIt = results.iterator();
}
public void send(Message message, Serializable messageKey) {
message.setMessageKey(messageKey);
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_TRANSPORT, MessageLevel.DETAIL)) {
LogManager.logDetail(LogConstants.CTX_TRANSPORT, "send message: " + message); // $NON-NLS-1$
}
objectSocket.write(message);
}
private void processMessagePacket(Message packet) {
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_TRANSPORT, MessageLevel.DETAIL)) {
LogManager.logDetail(
LogConstants.CTX_TRANSPORT, "processing message:" + packet); // $NON-NLS-1$
}
if (this.workContext.getSecurityHelper() != null) {
this.workContext.getSecurityHelper().clearSecurityContext();
}
final ServerWorkItem work = new ServerWorkItem(this, packet.getMessageKey(), packet, this.csr);
this.workContext.runInContext(work);
}
TempTable getOrCreateTempTable(
String tempTableID,
Command command,
BufferManager buffer,
boolean delegate,
boolean forUpdate,
CommandContext context)
throws TeiidProcessingException, BlockedException, TeiidComponentException {
TempTable tempTable = getTempTable(tempTableID, command, buffer, delegate, forUpdate, context);
if (tempTable != null) {
if (processors != null) {
TableProcessor withProcessor = processors.get(tempTableID);
if (withProcessor != null) {
buildWithTable(tempTableID, withProcessor, tempTable);
}
}
return tempTable;
}
// allow implicit temp group definition
List<ElementSymbol> columns = null;
if (command instanceof Insert) {
Insert insert = (Insert) command;
GroupSymbol group = insert.getGroup();
if (group.isImplicitTempGroupSymbol()) {
columns = insert.getVariables();
}
}
if (columns == null) {
if (processors != null) {
TableProcessor withProcessor = processors.get(tempTableID);
if (withProcessor != null) {
LogManager.logDetail(
LogConstants.CTX_DQP,
"Creating temporary table for with clause",
tempTableID); //$NON-NLS-1$
Create create = new Create();
create.setTable(new GroupSymbol(tempTableID));
create.setElementSymbolsAsColumns(withProcessor.columns);
tempTable = addTempTable(tempTableID, create, buffer, true, context);
buildWithTable(tempTableID, withProcessor, tempTable);
return tempTable;
}
}
throw new QueryProcessingException(
QueryPlugin.Event.TEIID30226,
QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30226, tempTableID));
}
LogManager.logDetail(
LogConstants.CTX_DQP, "Creating temporary table", tempTableID); // $NON-NLS-1$
Create create = new Create();
create.setTable(new GroupSymbol(tempTableID));
create.setElementSymbolsAsColumns(columns);
return addTempTable(tempTableID, create, buffer, true, context);
}
public void remove() {
if (!removed) {
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_BUFFER_MGR, MessageLevel.DETAIL)) {
LogManager.logDetail(
LogConstants.CTX_BUFFER_MGR,
"Removing TupleBuffer:",
this.tupleSourceID); // $NON-NLS-1$
}
this.batchBuffer = null;
purge();
this.manager.remove();
removed = true;
}
}
public static List<Object> performSearch(
Select command, Class<?> type, String cacheName, CacheContainerWrapper cache)
throws TranslatorException {
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Using Lucene Searching."); // $NON-NLS-1$
// Map<?, ?> cache,
SearchManager searchManager = Search.getSearchManager((Cache<?, ?>) cache.getCache(cacheName));
QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass(type).get();
BooleanJunction<BooleanJunction> junction = queryBuilder.bool();
boolean createdQueries = buildQueryFromWhereClause(command.getWhere(), junction, queryBuilder);
Query query = null;
if (createdQueries) {
query = junction.createQuery();
} else {
query = queryBuilder.all().createQuery();
}
CacheQuery cacheQuery = searchManager.getQuery(query, type); // rootNodeType
List<Object> results = cacheQuery.list();
if (results == null || results.isEmpty()) {
return Collections.emptyList();
}
return results;
}
public static boolean visit(
Like obj, BooleanJunction<BooleanJunction> junction, QueryBuilder queryBuilder)
throws TranslatorException {
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Parsing LIKE criteria."); // $NON-NLS-1$
Expression lhs = obj.getLeftExpression();
Expression rhs = obj.getRightExpression();
Column c = null;
Expression literalExp = null;
if (lhs instanceof ColumnReference) {
c = ((ColumnReference) lhs).getMetadataObject();
literalExp = rhs;
} else {
c = ((ColumnReference) rhs).getMetadataObject();
literalExp = lhs;
}
String value = null;
if (literalExp instanceof Literal) {
value = (String) escapeReservedChars(((Literal) literalExp).getValue());
createLikeQuery(
c, value.replaceAll("%", ""), junction, queryBuilder); // "*" //$NON-NLS-1$ //$NON-NLS-2$
} else {
final String msg =
ObjectPlugin.Util.getString(
"LuceneSearch.Unsupported_expression", //$NON-NLS-1$
new Object[] {literalExp.toString(), "LIKE"}); // $NON-NLS-1$
throw new TranslatorException(msg);
}
return true;
}
public ConnectorWork registerRequest(AtomicRequestMessage message)
throws TeiidComponentException {
checkStatus();
AtomicRequestID atomicRequestId = message.getAtomicRequestID();
LogManager.logDetail(
LogConstants.CTX_CONNECTOR, new Object[] {atomicRequestId, "Create State"}); // $NON-NLS-1$
final ConnectorWorkItem item = new ConnectorWorkItem(message, this);
ConnectorWork proxy =
(ConnectorWork)
Proxy.newProxyInstance(
ConnectorWork.class.getClassLoader(),
new Class[] {ConnectorWork.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
ClassLoader originalCL = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread()
.setContextClassLoader(getExecutionFactory().getClass().getClassLoader());
return method.invoke(item, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
} finally {
Thread.currentThread().setContextClassLoader(originalCL);
}
}
});
Assertion.isNull(
requestStates.put(atomicRequestId, proxy), "State already existed"); // $NON-NLS-1$
return proxy;
}
private BasicSourceCapabilities buildCapabilities(ExecutionFactory<Object, Object> translator)
throws TranslatorException {
if (translator.isSourceRequiredForCapabilities()) {
Object connection = null;
Object connectionFactory = null;
try {
connectionFactory = getConnectionFactory();
if (connectionFactory != null) {
connection = translator.getConnection(connectionFactory, null);
}
if (connection == null) {
throw new TranslatorException(
QueryPlugin.Event.TEIID31108,
QueryPlugin.Util.getString(
"datasource_not_found", getConnectionName())); // $NON-NLS-1$);
}
LogManager.logDetail(
LogConstants.CTX_CONNECTOR,
"Initializing the capabilities for",
translatorName); //$NON-NLS-1$
synchronized (executionFactory) {
executionFactory.initCapabilities(connection);
}
} finally {
if (connection != null) {
translator.closeConnection(connection, connectionFactory);
}
}
}
BasicSourceCapabilities resultCaps = CapabilitiesConverter.convertCapabilities(translator, id);
return resultCaps;
}
/** Set the standard request controls */
private void setRequestControls(byte[] cookie) throws TranslatorException {
List<Control> ctrl = new ArrayList<Control>();
SortKey[] keys = searchDetails.getSortKeys();
try {
if (keys != null) {
ctrl.add(new SortControl(keys, Control.NONCRITICAL));
}
if (this.executionFactory.usePagination()) {
ctrl.add(
new PagedResultsControl(
this.executionContext.getBatchSize(), cookie, Control.CRITICAL));
}
if (!ctrl.isEmpty()) {
this.ldapCtx.setRequestControls(ctrl.toArray(new Control[ctrl.size()]));
LogManager.logTrace(
LogConstants.CTX_CONNECTOR,
"Sort/pagination controls were created successfully."); //$NON-NLS-1$
}
} catch (NamingException ne) {
final String msg =
LDAPPlugin.Util.getString("LDAPSyncQueryExecution.setControlsError")
+ //$NON-NLS-1$
" : "
+ ne.getExplanation(); // $NON-NLS-1$
throw new TranslatorException(ne, msg);
} catch (IOException e) {
throw new TranslatorException(e);
}
}
// GHH 20080326 - set all batches as last batch after an exception
// is thrown calling a method on the enumeration. Per Javadoc for
// javax.naming.NamingEnumeration, enumeration is invalid after an
// exception is thrown - by setting last batch indicator we prevent
// it from being used again.
// GHH 20080326 - also added return of explanation for generic
// NamingException
public List<?> next() throws TranslatorException {
try {
if (unwrapIterator != null) {
if (unwrapIterator.hasNext()) {
return unwrapIterator.next();
}
unwrapIterator = null;
}
// The search has been executed, so process up to one batch of
// results.
List<?> result = null;
while (result == null && searchEnumeration != null && searchEnumeration.hasMore()) {
SearchResult searchResult = (SearchResult) searchEnumeration.next();
try {
result = getRow(searchResult);
} catch (InvalidNameException e) {
}
}
if (result == null && this.executionFactory.usePagination()) {
byte[] cookie = null;
Control[] controls = ldapCtx.getResponseControls();
if (controls != null) {
for (int i = 0; i < controls.length; i++) {
if (controls[i] instanceof PagedResultsResponseControl) {
PagedResultsResponseControl prrc = (PagedResultsResponseControl) controls[i];
cookie = prrc.getCookie();
}
}
}
if (cookie == null) {
return null;
}
setRequestControls(cookie);
executeSearch();
return next();
}
if (result != null) {
resultCount++;
}
return result;
} catch (SizeLimitExceededException e) {
if (resultCount != searchDetails.getCountLimit()) {
String msg = LDAPPlugin.Util.gs(LDAPPlugin.Event.TEIID12008);
TranslatorException te = new TranslatorException(e, msg);
if (executionFactory.isExceptionOnSizeLimitExceeded()) {
throw te;
}
this.executionContext.addWarning(te);
LogManager.logWarning(LogConstants.CTX_CONNECTOR, e, msg);
}
return null; // GHH 20080326 - if size limit exceeded don't try to read more results
} catch (NamingException ne) {
throw new TranslatorException(ne, LDAPPlugin.Util.gs("ldap_error")); // $NON-NLS-1$
}
}
public void reset() {
super.reset();
if (evaluator != null) {
evaluator.reset();
}
evaluatedParams = false;
if (parentContext != null) {
super.getContext().setVariableContext(parentContext);
}
createVariableContext();
CommandContext cc = super.getContext();
if (cc != null) {
// create fresh local state
setContext(cc.clone());
}
done = false;
currentState = null;
finalTupleSource = null;
beginBatch = 1;
batchRows = null;
lastBatch = false;
// reset program stack
programs.clear();
LogManager.logTrace(
org.teiid.logging.LogConstants.CTX_DQP, "ProcedurePlan reset"); // $NON-NLS-1$
}
@Override
public CountResponse executeCount(Query query, List<SQLParam> parameters) {
ConnectionImpl connection = null;
try {
String sql = query.toString();
LogManager.logDetail(LogConstants.CTX_ODATA, "Teiid-Query:", sql); // $NON-NLS-1$
connection = getConnection();
final PreparedStatementImpl stmt = connection.prepareStatement(sql);
if (!parameters.isEmpty()) {
for (int i = 0; i < parameters.size(); i++) {
stmt.setObject(i + 1, parameters.get(i).value, parameters.get(i).sqlType);
}
}
ResultSet rs = stmt.executeQuery();
rs.next();
int count = rs.getInt(1);
rs.close();
stmt.close();
return Responses.count(count);
} catch (Exception e) {
throw new ServerErrorException(e.getMessage(), e);
} finally {
try {
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
}
}
}
public void exceptionOccurred(Throwable t) {
LogManager.log(
t instanceof IOException ? MessageLevel.DETAIL : MessageLevel.ERROR,
LogConstants.CTX_TRANSPORT,
t,
"Unhandled exception, closing client instance"); //$NON-NLS-1$
}
public UsernameTokenProfile(String user, String passwd, boolean encryptedPassword) {
this.encryptedPassword = encryptedPassword;
this.passwd = passwd;
this.user = user;
LogManager.logDetail(
WSManagedConnectionFactory.UTIL.getString("using_username_profile")); // $NON-NLS-1$
}
/**
* Return the XMIHeader for the specified File or null if the file does not represent a MetaMatrix
* model file.
*
* @param resource The file of a metamatrix model file.
* @return The XMIHeader for the model file
*/
public static XMIHeader getXmiHeader(final File resource) {
if (resource != null && resource.isFile() && resource.exists() && resource.canRead()) {
// check cache
if (CACHE != null) {
XMIHeader header = CACHE.getCachedXmiHeader(resource);
if (header != null) {
return header;
}
}
try {
XMIHeader header = XMIHeaderReader.readHeader(resource);
// add to cache
if (CACHE != null) {
CACHE.setXmiHeaderToCache(resource, header);
}
return header;
} catch (TeiidException e) {
LogManager.logWarning(RuntimeMetadataPlugin.PLUGIN_ID, e, e.getMessage());
} catch (IllegalArgumentException iae) {
// Swallowing this exception because we're doing all three checks that would produce it.
// If this exception is caught, it's because the files really were closed/deleted in another
// thread and this
// thread didn't know about it.
// Fixes Defect 22117
}
}
return null;
}
public static boolean visit(
In obj, BooleanJunction<BooleanJunction> junction, QueryBuilder queryBuilder)
throws TranslatorException {
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Parsing IN criteria."); // $NON-NLS-1$
Expression lhs = obj.getLeftExpression();
Column mdIDElement = ((ColumnReference) lhs).getMetadataObject();
List<Expression> rhsList = obj.getRightExpressions();
boolean createdQuery = false;
for (Expression expr : rhsList) {
if (expr instanceof Literal) {
Literal literal = (Literal) expr;
// add these as OR queries
createEqualsQuery(
mdIDElement,
escapeReservedChars(literal.getValue()),
false,
false,
junction,
queryBuilder);
createdQuery = true;
} else {
String msg =
ObjectPlugin.Util.getString(
"LuceneSearch.Unsupported_expression", //$NON-NLS-1$
new Object[] {expr, "IN"}); // $NON-NLS-1$
throw new TranslatorException(msg);
}
}
return createdQuery;
}
@Override
public void cancel() throws TranslatorException {
LogManager.logDetail(
LogConstants.CTX_CONNECTOR,
SpreadsheetExecutionFactory.UTIL.getString("cancel_query")); // $NON-NLS-1$
this.rowIterator = null;
}
@Override
public void stop(StopContext context) {
this.repositoryInjector.getValue().removeTranslatorMetadata(this.translator.getName());
this.statusCheckerInjector.getValue().translatorRemoved(this.translator.getName());
LogManager.logInfo(
LogConstants.CTX_RUNTIME,
IntegrationPlugin.Util.gs(IntegrationPlugin.Event.TEIID50010, this.translator.getName()));
}
@Override
public void execute() throws TranslatorException {
this.visitor = new MongoDBSelectVisitor(this.executionFactory, this.metadata);
this.visitor.visitNode(this.command);
if (!this.visitor.exceptions.isEmpty()) {
throw this.visitor.exceptions.get(0);
}
LogManager.logInfo(LogConstants.CTX_CONNECTOR, this.command);
DBCollection collection =
this.mongoDB.getCollection(this.visitor.mongoDoc.getTargetTable().getName());
if (collection != null) {
// TODO: check to see how to pass the hint
ArrayList<DBObject> ops = new ArrayList<DBObject>();
buildAggregate(ops, "$project", this.visitor.unwindProject); // $NON-NLS-1$
if (this.visitor.project.isEmpty()) {
throw new TranslatorException(
MongoDBPlugin.Event.TEIID18025, MongoDBPlugin.Util.gs(MongoDBPlugin.Event.TEIID18025));
}
if (this.visitor.projectBeforeMatch) {
buildAggregate(ops, "$project", this.visitor.project); // $NON-NLS-1$
}
if (!this.visitor.unwindTables.isEmpty()) {
for (String ref : this.visitor.unwindTables) {
buildAggregate(ops, "$unwind", "$" + ref); // $NON-NLS-1$ //$NON-NLS-2$
}
}
buildAggregate(ops, "$match", this.visitor.match); // $NON-NLS-1$
buildAggregate(ops, "$group", this.visitor.group); // $NON-NLS-1$
buildAggregate(ops, "$match", this.visitor.having); // $NON-NLS-1$
if (!this.visitor.projectBeforeMatch) {
buildAggregate(ops, "$project", this.visitor.project); // $NON-NLS-1$
}
buildAggregate(ops, "$sort", this.visitor.sort); // $NON-NLS-1$
buildAggregate(ops, "$skip", this.visitor.skip); // $NON-NLS-1$
buildAggregate(ops, "$limit", this.visitor.limit); // $NON-NLS-1$
try {
AggregationOptions options =
AggregationOptions.builder()
.batchSize(this.executionContext.getBatchSize())
.outputMode(AggregationOptions.OutputMode.CURSOR)
.allowDiskUse(this.executionFactory.useDisk())
.build();
this.results = collection.aggregate(ops, options);
} catch (MongoException e) {
throw new TranslatorException(e);
}
}
}
/**
* Return the XMIHeader for the specified inputstream of a model file.
*
* @param resourceStream The inputStream of a metamatrix model file.
* @return The XMIHeader for the model file
*/
public static XMIHeader getXmiHeader(final InputStream resourceStream) {
if (resourceStream != null) {
try {
return XMIHeaderReader.readHeader(resourceStream);
} catch (TeiidException e) {
LogManager.logWarning(RuntimeMetadataPlugin.PLUGIN_ID, e, e.getMessage());
}
}
return null;
}
/*
* Deploy all jars in the supplied jarList
* @param admin the Admin instance
* @param jarList the colon-separated list of jar path locations
*/
private void deployJars(Admin admin, String jarList) {
// Path Entries are colon separated
String[] jarPathStrs = jarList.split("[:]"); // $NON-NLS-1$
// Attempt to deploy each jar
for (String jarPathStr : jarPathStrs) {
File theFile = new File(jarPathStr);
if (theFile.exists()) {
if (theFile.canRead()) {
String fileName = theFile.getName();
InputStream iStream = null;
try {
iStream = new FileInputStream(theFile);
} catch (FileNotFoundException ex) {
LogManager.logError(
getClass().getSimpleName(),
ex,
NLS.bind(Messages.JarDeploymentJarNotFound, theFile.getPath()));
continue;
}
try {
admin.deployVDB(fileName, iStream);
} catch (Exception ex) {
// Jar deployment failed
LogManager.logError(
getClass().getSimpleName(),
ex,
NLS.bind(Messages.JarDeploymentFailed, theFile.getPath()));
}
} else {
// Could not read the file
LogManager.logError(
getClass().getSimpleName(),
NLS.bind(Messages.JarDeploymentJarNotReadable, theFile.getPath()));
}
} else {
// The file was not found
LogManager.logError(
getClass().getSimpleName(),
NLS.bind(Messages.JarDeploymentJarNotFound, theFile.getPath()));
}
}
}
public <T> Dispatch<T> createDispatch(Class<T> type, Mode mode) throws IOException {
if (this.wsdlService == null) {
Bus bus = BusFactory.getThreadDefaultBus();
BusFactory.setThreadDefaultBus(this.mcf.getBus());
try {
this.wsdlService = Service.create(this.mcf.getWsdlUrl(), this.mcf.getServiceQName());
} finally {
BusFactory.setThreadDefaultBus(bus);
}
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_WS, MessageLevel.DETAIL)) {
LogManager.logDetail(
LogConstants.CTX_WS, "Created the WSDL service for", this.mcf.getWsdl()); // $NON-NLS-1$
}
}
Dispatch<T> dispatch = this.wsdlService.createDispatch(this.mcf.getPortQName(), type, mode);
configureWSSecurity(dispatch);
setDispatchProperties(dispatch, "SOAP12"); // $NON-NLS-1$
return dispatch;
}
/**
* @param port
* @param inputBufferSize
* @param outputBufferSize
* @param engine null if SSL is disabled
* @param bindaddress
* @param server
*/
public SocketListener(
InetSocketAddress address,
int inputBufferSize,
int outputBufferSize,
int maxWorkers,
SSLConfiguration config,
ClientServiceRegistryImpl csr,
StorageManager storageManager) {
if (config != null) {
this.isClientEncryptionEnabled = config.isClientEncryptionEnabled();
}
this.csr = csr;
this.nettyPool = Executors.newCachedThreadPool(new NamedThreadFactory("NIO")); // $NON-NLS-1$
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_TRANSPORT, MessageLevel.DETAIL)) {
LogManager.logDetail(
LogConstants.CTX_TRANSPORT,
"server = "
+ address.getAddress()
+ "binding to port:"
+ address.getPort()); // $NON-NLS-1$ //$NON-NLS-2$
}
if (maxWorkers == 0) {
maxWorkers = Runtime.getRuntime().availableProcessors();
}
ChannelFactory factory =
new NioServerSocketChannelFactory(this.nettyPool, this.nettyPool, maxWorkers);
ServerBootstrap bootstrap = new ServerBootstrap(factory);
this.channelHandler = createChannelPipelineFactory(config, storageManager);
bootstrap.setPipelineFactory(channelHandler);
if (inputBufferSize != 0) {
bootstrap.setOption("receiveBufferSize", new Integer(inputBufferSize)); // $NON-NLS-1$
}
if (outputBufferSize != 0) {
bootstrap.setOption("sendBufferSize", new Integer(outputBufferSize)); // $NON-NLS-1$
}
bootstrap.setOption("keepAlive", Boolean.TRUE); // $NON-NLS-1$
this.serverChanel = bootstrap.bind(address);
}
public ResultsFuture<?> ping() throws InvalidSessionException, TeiidComponentException {
// ping is double used to alert the aliveness of the client, as well as check the server
// instance is
// alive by socket server instance, so that they can be cached.
String id = DQPWorkContext.getWorkContext().getSessionId();
if (id != null) {
this.service.pingServer(id);
}
LogManager.logTrace(LogConstants.CTX_SECURITY, "Ping", id); // $NON-NLS-1$
return ResultsFuture.NULL_FUTURE;
}
public void stop() {
LogManager.logDetail(
LogConstants.CTX_DQP, "Stopping BufferManager using", bufferDir); // $NON-NLS-1$
bufferMgr.shutdown();
// Delete the buffer directory
if (bufferDir != null) {
cleanDirectory(bufferDir);
bufferDir.delete();
}
}
/**
* Close processing and clean everything up. Should only be called by the same thread that called
* process.
*/
public void closeProcessing() {
if (processorClosed) {
return;
}
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_DQP, MessageLevel.DETAIL)) {
LogManager.logDetail(
LogConstants.CTX_DQP, "QueryProcessor: closing processor"); // $NON-NLS-1$
}
this.context.getTupleSourceCache().close();
this.bufferMgr.releaseBuffers(reserved);
reserved = 0;
processorClosed = true;
if (initialized) {
try {
processPlan.close();
} catch (TeiidComponentException e1) {
LogManager.logDetail(LogConstants.CTX_DQP, e1, "Error closing processor"); // $NON-NLS-1$
}
}
}
private void buildAggregate(List<DBObject> query, String type, Object object) {
if (object != null) {
LogManager.logDetail(
LogConstants.CTX_CONNECTOR,
"{\""
+ type
+ "\": {"
+ object.toString()
+ "}}"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
query.add(new BasicDBObject(type, object));
}
}
@Override
public void processError(ODataServerError error, ErrorResponse response) {
int logLevel = error.getStatusCode() >= 500 ? MessageLevel.ERROR : MessageLevel.WARNING;
Throwable ex = getRoot(error.getException());
// many exceptions in TeiidServiceHandler default as INTERNAL_SERVER_ERROR
// so we make a better check for codes here
if (ex instanceof TeiidNotImplementedException) {
error.setException((TeiidNotImplementedException) ex);
error.setCode(((TeiidNotImplementedException) ex).getCode());
error.setStatusCode(501);
logLevel = MessageLevel.DETAIL;
} else if (ex instanceof TeiidProcessingException) {
error.setException((TeiidProcessingException) ex);
error.setCode(((TeiidProcessingException) ex).getCode());
error.setStatusCode(400);
logLevel = MessageLevel.WARNING;
} else if (ex instanceof TeiidException) {
error.setException((TeiidException) ex);
error.setCode(((TeiidException) ex).getCode());
error.setStatusCode(500);
logLevel = MessageLevel.ERROR;
} else if (ex instanceof TeiidRuntimeException) {
error.setException((TeiidRuntimeException) ex);
error.setCode(((TeiidRuntimeException) ex).getCode());
error.setStatusCode(500);
logLevel = MessageLevel.ERROR;
}
if (ex != error.getException() && ex.getMessage() != null) {
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_ODATA, MessageLevel.DETAIL)
|| logLevel <= MessageLevel.ERROR) {
LogManager.log(
logLevel,
LogConstants.CTX_ODATA,
error.getException(),
ODataPlugin.Util.gs(ODataPlugin.Event.TEIID16050, error.getMessage(), ex.getMessage()));
} else {
LogManager.log(
logLevel,
LogConstants.CTX_DQP,
ODataPlugin.Util.gs(ODataPlugin.Event.TEIID16051, error.getMessage(), ex.getMessage()));
}
} else {
if (LogManager.isMessageToBeRecorded(LogConstants.CTX_ODATA, MessageLevel.DETAIL)
|| logLevel <= MessageLevel.ERROR) {
LogManager.log(
logLevel,
LogConstants.CTX_ODATA,
error.getException(),
ODataPlugin.Util.gs(ODataPlugin.Event.TEIID16052, error.getMessage()));
} else {
LogManager.log(
logLevel,
LogConstants.CTX_DQP,
ODataPlugin.Util.gs(ODataPlugin.Event.TEIID16053, error.getMessage()));
}
}
response.writeError(error);
}
public void resolveBlock(
CreateProcedureCommand command,
Block block,
GroupContext originalExternalGroups,
TempMetadataAdapter original)
throws QueryResolverException, QueryMetadataException, TeiidComponentException {
LogManager.logTrace(
org.teiid.logging.LogConstants.CTX_QUERY_RESOLVER,
new Object[] {"Resolving block", block}); // $NON-NLS-1$
// create a new variable and metadata context for this block so that discovered metadata is not
// visible else where
TempMetadataStore store = original.getMetadataStore().clone();
TempMetadataAdapter metadata = new TempMetadataAdapter(original.getMetadata(), store);
GroupContext externalGroups = new GroupContext(originalExternalGroups, null);
// create a new variables group for this block
GroupSymbol variables =
ProcedureContainerResolver.addScalarGroup(
ProcedureReservedWords.VARIABLES, store, externalGroups, new LinkedList<Expression>());
for (Statement statement : block.getStatements()) {
resolveStatement(command, statement, externalGroups, variables, metadata);
}
if (block.getExceptionGroup() != null) {
// create a new variable and metadata context for this block so that discovered metadata is
// not visible else where
store = original.getMetadataStore().clone();
metadata = new TempMetadataAdapter(original.getMetadata(), store);
externalGroups = new GroupContext(originalExternalGroups, null);
// create a new variables group for this block
variables =
ProcedureContainerResolver.addScalarGroup(
ProcedureReservedWords.VARIABLES,
store,
externalGroups,
new LinkedList<Expression>());
isValidGroup(metadata, block.getExceptionGroup());
if (block.getExceptionStatements() != null) {
ProcedureContainerResolver.addScalarGroup(
block.getExceptionGroup(), store, externalGroups, exceptionGroup, false);
for (Statement statement : block.getExceptionStatements()) {
resolveStatement(command, statement, externalGroups, variables, metadata);
}
}
}
}
