Example #1
0
        public ADOMD.AdomdDataReader ExecuteReader(string qry, ADOMD.AdomdConnection cnn)
        {
            var cmd = new ADOMD.AdomdCommand(qry, cnn);

            ADOMD.AdomdDataReader reader = cmd.ExecuteReader();
            return(reader);
        }
Example #2
0
        /*
         * Return results from query
         */
        public AdomdDataReader GetQueryResult(string sQuery)
        {
            try
            {
                string sConnString = "Data Source=" + sServer + "; Initial Catalog=" + sCatalog;
                Microsoft.AnalysisServices.AdomdClient.AdomdConnection objConn = new Microsoft.AnalysisServices.AdomdClient.AdomdConnection(sConnString);
                objConn.Open();
                Microsoft.AnalysisServices.AdomdClient.AdomdCommand objCmd = objConn.CreateCommand();
                objCmd.CommandText = sQuery;

                //Microsoft.AnalysisServices.AdomdClient.AdomdDataReader objReader = objCmd.ExecuteReader();
                //Microsoft.AnalysisServices.AdomdClient.AdomdDataAdapter objDataAdaptor = new Microsoft.AnalysisServices.AdomdClient.AdomdDataAdapter(objCmd);

                Microsoft.AnalysisServices.AdomdClient.AdomdDataReader objDataReader = objCmd.ExecuteReader(CommandBehavior.CloseConnection);

                /*
                 * try
                 * {
                 *  for (int i = 0; i < objDataReader.FieldCount; i++)
                 *  {
                 *      Console.Write(objDataReader.GetName(i) + "\t");
                 *  }
                 *  Console.WriteLine();
                 *  while (objDataReader.Read())
                 *  {
                 *      for (int i = 0; i < objDataReader.FieldCount; i++)
                 *      {
                 *          object value = objDataReader.GetValue(i);
                 *          string strValue = (value == null) ?
                 *          string.Empty : value.ToString();
                 *          Console.Write(strValue + "\t");
                 *      }
                 *      Console.WriteLine();
                 *  }
                 * }
                 * finally
                 * {
                 *  objDataReader.Close();
                 * }
                 */

                return(objDataReader);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.StackTrace);
            }

            return(null);
        }
        public object Execute()
        {
            this.CheckCanExecute();
            XmlaReader xmlaReader = null;

            xmlaReader = this.connection.IExecuteProvider.Execute(this, this.Properties, this.PrivateParameters);
            this.Connection.OpenedReader = null;
            if (xmlaReader == null)
            {
                this.connection.MarkCacheNeedsCheckForValidness();
                return(null);
            }
            object result;

            try
            {
                object obj = null;
                if (XmlaClient.IsExecuteResponseS(xmlaReader))
                {
                    XmlaClient.StartExecuteResponseS(xmlaReader);
                    if (XmlaClient.IsDatasetResponseS(xmlaReader))
                    {
                        MDDatasetFormatter mDDatasetFormatter = SoapFormatter.ReadDataSetResponse(xmlaReader);
                        if (mDDatasetFormatter != null)
                        {
                            obj = new CellSet(this.connection, mDDatasetFormatter);
                        }
                    }
                    else if (XmlaClient.IsRowsetResponseS(xmlaReader))
                    {
                        obj = AdomdDataReader.CreateInstance(xmlaReader, CommandBehavior.Default, this.connection);
                    }
                    else if (XmlaClient.IsEmptyResultS(xmlaReader))
                    {
                        this.connection.MarkCacheNeedsCheckForValidness();
                        XmlaClient.ReadEmptyRootS(xmlaReader);
                    }
                    else
                    {
                        if (!XmlaClient.IsMultipleResult(xmlaReader) && !XmlaClient.IsAffectedObjects(xmlaReader))
                        {
                            this.connection.MarkCacheNeedsCheckForValidness();
                            throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, string.Format(CultureInfo.InvariantCulture, "Expected dataset, rowset, empty or multiple results, got {0}", new object[]
                            {
                                xmlaReader.Name
                            }));
                        }
                        this.connection.MarkCacheNeedsCheckForValidness();
                        XmlaClient.ReadMultipleResults(xmlaReader);
                    }
                }
                if (!(obj is AdomdDataReader))
                {
                    xmlaReader.Close();
                }
                else
                {
                    this.Connection.OpenedReader = obj;
                }
                result = obj;
            }
            catch (AdomdUnknownResponseException)
            {
                if (xmlaReader != null)
                {
                    xmlaReader.Close();
                }
                throw;
            }
            catch (AdomdConnectionException)
            {
                throw;
            }
            catch (XmlException innerException)
            {
                if (xmlaReader != null)
                {
                    xmlaReader.Close();
                }
                throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, innerException);
            }
            catch (IOException innerException2)
            {
                if (this.connection != null)
                {
                    this.connection.Close(false);
                }
                throw new AdomdConnectionException(XmlaSR.ConnectionBroken, innerException2);
            }
            catch (XmlaException innerException3)
            {
                if (xmlaReader != null)
                {
                    xmlaReader.Close();
                }
                throw new AdomdErrorResponseException(innerException3);
            }
            catch
            {
                if (this.connection != null)
                {
                    this.connection.Close(false);
                }
                throw;
            }
            return(result);
        }
 public AdomdDataReader(AsAdomdClient.AdomdDataReader obj)
 {
     _type   = AdomdType.AnalysisServices;
     _reader = obj;
 }
            internal Enumerator(AdomdDataReader dataReader, CommandBehavior commandBehavior)
            {
                bool closeReader = (CommandBehavior.CloseConnection & commandBehavior) != CommandBehavior.Default;

                this.enumerator = new DbEnumerator(dataReader, closeReader);
            }