Beispiel #1
0
        public void GetParameter()
        {
            SqlType type = new SqlXml(testXml, ParameterDirection.Input);
            TestHelper.AssertSqlParameter(type.GetParameter(), SqlDbType.Xml, testXml);

            type = new SqlXml(null, ParameterDirection.Input);
            TestHelper.AssertSqlParameter(type.GetParameter(), SqlDbType.Xml, DBNull.Value);
        }
Beispiel #2
0
        public void GetRawValue()
        {
            SqlType type = new SqlXml(testXml, ParameterDirection.Input);
            Assert.AreEqual(testXml, type.GetRawValue());

            type = new SqlXml(null, ParameterDirection.Input);
            Assert.Null(type.GetRawValue());
        }
Beispiel #3
0
        public void CreateMetaData()
        {
            Assert.Throws<TypeCannotBeUsedAsAClrTypeException>(() => SqlXml.GetTypeHandler().CreateMetaData(null));

            SqlTypeHandler col = new SqlXml(testXml, ParameterDirection.Input);
            var meta = col.CreateMetaData("Test");
            Assert.AreEqual(SqlDbType.Xml, meta.SqlDbType);
            Assert.AreEqual(-1, meta.MaxLength);
            Assert.AreEqual("Test", meta.Name);
        }
Beispiel #4
0
        private static void ReadXmlFile(string filename)
        {
            XmlDocument doc     = new XmlDocument();
            DbClass     dbClass = new DbClass();

            doc.Load(filename);

            StringWriter  sw = new StringWriter();
            XmlTextWriter xw = new XmlTextWriter(sw);

            doc.WriteTo(xw);
            StringReader  transactionXml = new StringReader(sw.ToString());
            XmlTextReader xmlReader      = new XmlTextReader(transactionXml);
            SqlXml        sqlXml         = new SqlXml(xmlReader);

            dbClass.ImportData(sqlXml);
        }
Beispiel #5
0
    protected void buildInventoryMain_Graphics(SqlDataReader reader)
    
    {
        
           
            if (!reader.IsDBNull(reader.GetOrdinal("xmlProductDtls1")))
            {
                SqlXml sqlXmlValue = reader.GetSqlXml(reader.GetOrdinal("xmlProductDtls1"));
                buildInventoryDetails_Graphics(CommonFunctions.isDbReaderNull(reader, reader.GetOrdinal("listName1")), sqlXmlValue, placeHolderA1, 1);
            }
            if (!reader.IsDBNull(reader.GetOrdinal("xmlProductDtls2")))
            {
                SqlXml sqlXmlValue = reader.GetSqlXml(reader.GetOrdinal("xmlProductDtls2"));
                buildInventoryDetails_Graphics(CommonFunctions.isDbReaderNull(reader, reader.GetOrdinal("listName2")), sqlXmlValue, placeHolderB1, 2);
            }

            if (!reader.IsDBNull(reader.GetOrdinal("xmlProductDtls3")))
            {
                SqlXml sqlXmlValue = reader.GetSqlXml(reader.GetOrdinal("xmlProductDtls3"));
                buildInventoryDetails_Graphics(CommonFunctions.isDbReaderNull(reader, reader.GetOrdinal("listName3")), sqlXmlValue, placeHolderC1, 3);
            }
            if (!reader.IsDBNull(reader.GetOrdinal("xmlProductDtls4")))
            {
                SqlXml sqlXmlValue = reader.GetSqlXml(reader.GetOrdinal("xmlProductDtls4"));
                buildInventoryDetails_Graphics(CommonFunctions.isDbReaderNull(reader, reader.GetOrdinal("listName4")), sqlXmlValue, placeHolderD1, 4);
            }
            if (!reader.IsDBNull(reader.GetOrdinal("xmlProductDtls5")))
            {
                SqlXml sqlXmlValue = reader.GetSqlXml(reader.GetOrdinal("xmlProductDtls5"));
                buildInventoryDetails_Graphics(CommonFunctions.isDbReaderNull(reader, reader.GetOrdinal("listName5")), sqlXmlValue, placeHolderD1, 5);
            }

            if (!reader.IsDBNull(reader.GetOrdinal("docPath")))
            {

                Literal invtabLI = new Literal();
                invtabLI.Text = "<li><a href='#UpdatePanelDocs'><span>Downloads</span></a></li> ";
                placeHolderInvContainer.Controls.Add(invtabLI);

                Literal invtabDiv = new Literal();
                invtabDiv.Text = "<div style='width:400px;height:200px;text-align:center;background-color:white;font-size:small; font-weight:bold; color:#669;'><a href='" + reader.GetValue(reader.GetOrdinal("docPath")) + "'>Click to view inventory document</a></div>";
                placeHolderDocs.Controls.Add(invtabDiv);


            }
    }
Beispiel #6
0
        public static void HttpPost(
            SqlString url,
            SqlXml headerXml,
            SqlString requestBody,
            out SqlBoolean success,
            out SqlString response,
            out SqlString error)
        {
            List <KeyValuePair <string, string> > headers = ClrHttp.GetHeaders(headerXml);
            string     url1         = url.IsNull ? (string)null : url.Value;
            string     requestBody1 = requestBody.IsNull ? (string)null : requestBody.Value;
            HttpResult httpResult   = HttpLayer.Post(url1, (IEnumerable <KeyValuePair <string, string> >)headers, requestBody1);

            success  = (SqlBoolean)httpResult.Success;
            response = (SqlString)httpResult.Response;
            error    = (SqlString)httpResult.Error;
        }
        public void ReceiveMessage(out string MessageType, out string Message, out Guid ConversationGroupID, out Guid DialogHandle)
        {
            //default return values
            MessageType         = null;
            Message             = null;
            ConversationGroupID = Guid.Empty;
            DialogHandle        = Guid.Empty;


            SqlCommand cmd = _cnn.CreateCommand();

            cmd.Transaction    = _trans;
            cmd.CommandTimeout = _receiveTimeout / 1000 + 2;

            cmd.CommandText = "WAITFOR (RECEIVE TOP(1)  message_type_name, " +
                              "CAST(message_body AS XML), " +
                              "conversation_group_id, " +
                              "conversation_handle FROM [" + _queueName +
                              "]), TIMEOUT " + _receiveTimeout;

            try
            {
                SqlDataReader rdr = cmd.ExecuteReader();

                if (rdr.HasRows)
                {
                    rdr.Read();
                    MessageType = (String)rdr.GetSqlString(0);
                    SqlXml sx = rdr.GetSqlXml(1);

                    if (!sx.IsNull)
                    {
                        Message = sx.Value;
                    }

                    ConversationGroupID = rdr.GetGuid(2);
                    DialogHandle        = rdr.GetGuid(3);
                }

                rdr.Close();
            }
            catch (SqlException e)
            {
                Console.WriteLine("RECEIVE failed " + e.Message);
            }
        }
Beispiel #8
0
        public void SerializationDeepTargetTest()
        {
            //Set up the model
            Model model = new Model();

            model.SetSize(new SizeF(1000, 1000)); //Set the container size so that the shape can be moved

            //Set up a shape element
            Shape shape = new Shape();

            shape.Location = new PointF(100, 100);
            model.Shapes.Add("Shape1", shape);

            //Set up another shape element
            Shape shape2 = new Shape();

            shape2.Location = new PointF(200, 200);
            model.Shapes.Add("Shape2", shape2);

            //Connect with a line
            Link line = new Link(shape, shape2);

            model.Lines.Add("Line1", line);

            //Serialize the model
            MemoryStream stream     = new MemoryStream();
            XmlFormatter serializer = new XmlFormatter();

            serializer.Shallow = false;

            serializer.Serialize(stream, model);
            stream.Position = 0; // reset the stream to the beginning
            SqlXml xml = new SqlXml(stream);

            //Stream the data back into the same model object
            serializer.Target = model;

            using (MemoryStream stream2 = new MemoryStream(Encoding.UTF8.GetBytes(xml.Value)))
            {
                serializer.Deserialize(stream2);
            }

            Assert.IsTrue(model.Shapes.Count == 2, "Shapes count not set back to 2.");
            Assert.IsTrue(model.Lines.Count == 1, "Line count not set back to 1.");
        }
Beispiel #9
0
        /// <summary>
        /// Retrieves xml with a maximum number of bytes to return
        /// </summary>
        /// <param name="iCol">Column ordinal</param>
        /// <param name="maxCharsToReturn">Number of chars to return at maximum</param>
        /// <returns>String</returns>
        public string GetXmlWithMaxCapacity(int iCol, int maxCharsToReturn)
        {
            if (maxCharsToReturn <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(maxCharsToReturn), SR.QueryServiceDataReaderXmlCountInvalid);
            }

            // If we're not in SQL XML mode, just return the entire thing as a string
            if (!supportSqlXml)
            {
                object o = GetValue(iCol);
                return(o?.ToString());
            }

            // We have SQL XML support, so write it properly
            SqlXml sm = GetSqlXml(iCol);

            if (sm == null)
            {
                return(null);
            }

            // Setup the writer so that we don't close the memory stream and can process fragments
            // of XML
            XmlWriterSettings writerSettings = new XmlWriterSettings
            {
                CloseOutput      = false, // don't close the memory stream
                ConformanceLevel = ConformanceLevel.Fragment
            };

            using (StringWriterWithMaxCapacity sw = new StringWriterWithMaxCapacity(null, maxCharsToReturn))
                using (XmlWriter ww = XmlWriter.Create(sw, writerSettings))
                    using (XmlReader reader = sm.CreateReader())
                    {
                        reader.Read();

                        while (!reader.EOF)
                        {
                            ww.WriteNode(reader, true);
                        }

                        ww.Flush();
                        return(sw.ToString());
                    }
        }
Beispiel #10
0
        static string GetSQLXmlString <T>(SQLXMLEdm sqlXMLEdm)
        {
            SqlXml sqlXml = new SqlXml();

            if (sqlXMLEdm != null && !sqlXMLEdm.IsNull && !string.IsNullOrEmpty(sqlXMLEdm.Value))
            {
                var pages = XmlSerializeHelper.DESerializer <List <T> >(sqlXMLEdm.Value);
                sqlXml = XmlSerializeHelper.ToSqlXml(pages);
            }
            if (sqlXml == null || sqlXml.IsNull == true)
            {
                return(null);
            }
            else
            {
                return(sqlXml.Value);
            }
        }
Beispiel #11
0
        public void TestGetValue(TestCaseResult result)
        {
            InsertRowText();

            VirtuosoCommand cmd = connection.CreateCommand();

            cmd.CommandText = "select data from xmlt";

            VirtuosoDataReader rdr = cmd.ExecuteReader();

            rdr.Read();
            object obj = rdr.GetValue(0);

            result.FailIfNotEqual(typeof(SqlXml).Name, obj.GetType().Name);
            SqlXml x = (SqlXml)obj;

            FailIfXmlNotEqual(result, x.ToString(), TheXml);
        }
        public void TestCreateActivityWithMissingMessageElement()
        {
            string xml =
                "<activity xmlns=\"http://ns.opensocial.org/2008/opensocial\"><postedTime>1304533194580</postedTime><body>This is Profiles test activity from ChatterSqlProceduresTest</body></activity>";
            var xmlReader = XmlTextReader.Create(new System.IO.StringReader(xml));

            SqlXml messageBlob = new SqlXml(xmlReader);

            try
            {
                //ChatterSqlProcedures.CreateActivity(_url, _username, _password, _token, _employeeId, messageBlob, _pmid, _title, _body);
                Assert.Fail("CreateActivity method should throw and exception if xml is incorrect");
            }
            catch (Exception ex)
            {
                Assert.AreEqual("Element {http://ns.opensocial.org/2008/opensocial}title was not found", ex.Message);
            }
        }
        public static void ProcessJobServerTasks(SqlXml Message, Guid ConversationHandle)
        {
            if (Message.IsNull)
            {
                SqlContext.Pipe.Send("No message was supplied for processing.");
                new ServiceBroker("context connection=true;").EndDialog(ConversationHandle);
                return;
            }

            XmlDocument doc = new System.Xml.XmlDocument();

            doc.LoadXml(Message.Value);

            // Execute the requested task
            IJobServerTask task = JobServerFactory.GetJobServerTask(doc.DocumentElement.Attributes["MessageTypeName"].Value);

            task.Execute(Message, ConversationHandle);
        }
Beispiel #14
0
        /// <summary>
        /// Creates the SQL XML parameter.
        /// </summary>
        /// <param name="name">Parameter name.</param>
        /// <param name="value">Parameter value.</param>
        /// <returns>Created <see cref="SqlParameter"/>. Contains DBNull.Value if input value is null.</returns>
        private SqlParameter CreateSqlXmlParameter(string name, XDocument value)
        {
            SqlParameter param = new SqlParameter(name, SqlDbType.Xml);

            if (value != null)
            {
                XmlReader reader = value.CreateReader();
                SqlXml    xml    = new SqlXml(reader);
                reader.Close();
                param.SqlValue = xml;
            }
            else
            {
                param.Value = DBNull.Value;
            }

            return(param);
        }
        public void TestCreateActivityWithIncorrectEmployee()
        {
            string xml =
                "<activity xmlns=\"http://ns.opensocial.org/2008/opensocial\"><postedTime>1304533194580</postedTime><title>This is Profiles test activity from ChatterSqlProceduresTest</title></activity>";
            var xmlReader = XmlTextReader.Create(new System.IO.StringReader(xml));

            SqlXml messageBlob = new SqlXml(xmlReader);

            try
            {
                //ChatterSqlProcedures.CreateActivity(_url, _username, _password, _token, "1221212", messageBlob, _pmid, _title, _body);
                Assert.Fail("CreateActivity method should throw and exception if user is not found by employee id");
            }
            catch (Exception ex)
            {
                Assert.AreEqual("Object not found, Salesforce.User, keys:1221212", ex.Message);
            }
        }
Beispiel #16
0
        public Task <Result> Visit(StoreDocumentCommand storeDocumentCommand)
        {
            var document = storeDocumentCommand.Document;

            if (document == null)
            {
                throw new ArgumentNullException("document");
            }
            if (document.Content == null)
            {
                throw new ArgumentException("Document Content cannot be null", "document");
            }

            return(Task.Factory.StartNew <Result>(() =>
            {
                var xmlElm = (XElement)document.Content.ToXNode();
                xmlElm.Add(new XAttribute(XNamespace.Xmlns.GetName("jxml"), JsonXml.JsonXmlSettings.JXmlNamespace),
                           new XAttribute(XNamespace.Xmlns.GetName("jsonx"), JsonXml.JsonXmlSettings.JsonNetXmlNamespace));

                using (var conn = new SqlConnection(_connectionString))
                    using (var cmd = new SqlCommand())
                    {
                        conn.Open();
                        cmd.Connection = conn;
                        cmd.CommandType = System.Data.CommandType.StoredProcedure;
                        cmd.CommandText = "dbo.StoreDocument";

                        if (document.Meta != null)
                        {
                            cmd.Parameters.Add(new SqlParameter("DocumentId", document.Meta.Id));
                            cmd.Parameters.Add(new SqlParameter("FriendlyId", document.Meta.Name));
                            cmd.Parameters.Add(new SqlParameter("RevisionEtag", document.Meta.RevisionEtag));
                        }

                        var xmlContent = new SqlXml(xmlElm.CreateReader());
                        cmd.Parameters.AddWithValue("Content", xmlContent);

                        using (var sqlReader = cmd.ExecuteReader())
                        {
                            return MapRecord(sqlReader);
                        }
                    }
            }));
        }
    public static SqlXml xfnCheckPlanXml(
        [SqlFacet(MaxSize = 512, IsNullable = true)]
        SqlString validationConfig,
        [SqlFacet(MaxSize = 128, IsNullable = false)]
        SqlString dbName,
        [SqlFacet(MaxSize = -1, IsNullable = true)]
        SqlXml planXml
        )
    {
        if (planXml.IsNull)
        {
            return(SqlXml.Null);
        }

        var    xml    = planXml.Value;
        string config = null;

        if (!validationConfig.IsNull)
        {
            config = validationConfig.Value;
        }

        var planValidator = new PlanValidator(config);
        var results       = planValidator.ValidateSqlPlan(xml).ToList();

        // ReSharper disable once SimplifyLinqExpression
        if (!results.Any(r => r.Category != PlanCategory.Trace))
        {
            return(SqlXml.Null);
        }

        var resultElement = planValidator.GenerateResultsElement(results);

        resultElement.Add(new XAttribute("dbName", dbName.Value));

        SqlXml ret;

        using (var reader = new StringReader(resultElement.ToString()))
            using (var xmlreader = new XmlTextReader(reader))
            {
                ret = new SqlXml(xmlreader);
            }
        return(ret);
    }
Beispiel #18
0
        public static void _ListQueuesCallback(Object obj,
                                               out SqlString name,
                                               out SqlString url,
                                               out SqlXml metadata)
        {
            if (!(obj is ITPCfSQL.Azure.Queue))
            {
                throw new ArgumentException("Expected " + typeof(ITPCfSQL.Azure.Queue).ToString() + ", received " + obj.GetType().ToString());
            }

            ITPCfSQL.Azure.Queue q = (ITPCfSQL.Azure.Queue)obj;

            name = q.Name;
            url  = q.Url.ToString();

            if ((q.Metadata != null) && (q.Metadata.Count > 0))
            {
                System.IO.MemoryStream ms = new System.IO.MemoryStream();

                using (System.Xml.XmlWriter wr = System.Xml.XmlWriter.Create(ms))
                {
                    wr.WriteStartElement("MetadataList");

                    foreach (string s in q.Metadata.Keys)
                    {
                        wr.WriteStartElement(s);
                        wr.WriteString(q.Metadata[s]);
                        wr.WriteEndElement();
                    }

                    wr.WriteEndElement();

                    wr.Flush();
                    wr.Close();
                }

                ms.Seek(0, System.IO.SeekOrigin.Begin);
                metadata = new SqlXml(ms);
            }
            else
            {
                metadata = null;
            }
        }
Beispiel #19
0
        public bool UpdateFileContent(long fileID, XmlDocument contents)
        {
            bool updated = false;

            using (DbCommand cmd = _db.GetStoredProcCommand("UpdateXmlRepositoryContent"))
            {
                if (dbCommandTimeout != null)
                {
                    cmd.CommandTimeout = dbCommandTimeout.Value;
                }
                _db.AddInParameter(cmd, "@FileID", DbType.Int64, fileID);
                MemoryStream ms = new MemoryStream();
                contents.Save(ms);
                SqlXml sqlXml = new SqlXml(ms);
                _db.AddInParameter(cmd, "@Contents", DbType.Xml, sqlXml);
                updated = Convert.ToInt32(_db.ExecuteScalar(cmd)) > 0;
            }
            return(updated);
        }
Beispiel #20
0
        public static SqlXml ExecXQuery(SqlXml Source, SqlString XQuery)
        {
            using (var q = new SqlCommand())
            {
                q.Connection  = new SqlConnection("context connection=true");
                q.CommandType = CommandType.Text;


                q.CommandText =
                    String.Format("SELECT @X.query('{0}')",
                                  XQuery.Value.Replace("'", "''"));

                q.Parameters.Add("@X", SqlDbType.Xml).Direction = ParameterDirection.Input;
                q.Parameters["@X"].Value = Source.Value;

                q.Connection.Open();
                return(new SqlXml(q.ExecuteXmlReader()));
            }
        }
Beispiel #21
0
 public static SqlBoolean ExecXSD(SqlXml Source, SqlXml XSD)
 {
     try
     {
         var settings = new XmlReaderSettings();
         settings.Schemas.Add(null, XSD.CreateReader());
         settings.ConformanceLevel = ConformanceLevel.Auto;
         settings.ValidationType   = ValidationType.Schema;
         var reader = XmlReader.Create(Source.CreateReader(), settings);
         while (reader.Read())
         {
         }
         return(true);
     }
     catch
     {
         return(false);
     }
 }
Beispiel #22
0
        /// <summary>
        /// Identical to calling GetSqlXml on the SqlDataReader returned
        /// from SqlCommand.ExecuteReader
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public SqlXml GetSqlXml(int index)
        {
            // Fail if the command wasn't executed
            if (m_reader == null)
            {
                throw new LearningComponentsInternalException("LSTR1270");
            }

            // Get the value
            SqlXml returnValue = m_reader.GetSqlXml(index);

            // Log
            if (m_log != null)
            {
                LogResultSetValue(index, returnValue);
            }

            return(returnValue);
        }
Beispiel #23
0
        internal override object ConvertValue(object value)
        {
            object ret = null;

            Debug.WriteLineIf(CLI.FnTrace.Enabled, "BufferTypeSqlXml.ConvertValue (" + value + ")");
            if (value is string)
            {
                ret = new SqlXml((string)value);
            }
            else if (value is XmlReader)
            {
                ret = new SqlXml((XmlReader)value);
            }
            else
            {
                ret = base.ConvertValue(value);
            }
            return(ret);
        }
Beispiel #24
0
	public static int SqlSafeScalar( SqlString sqlcmd, SqlXml values ){
		int			    n = 0;
		SqlConnection	conn = new SqlConnection("context connection=true");
		SqlCommand		cmd = new SqlCommand(sqlcmd.ToString(), conn);
		conn.Open();
		cmd.CommandType = CommandType.Text;
		cmd.CommandTimeout = 0;

		n = SqlSafeParmsEx( ref cmd, values );
		try{
			n = (int)cmd.ExecuteScalar();
		}
		catch (Exception ed){
			throw new Exception(ed.Message + "\n" +
					@sqlcmd.ToString() );
		}
		conn.Close();
		return n;
	}//end SqlSafeScalar
Beispiel #25
0
        public override string GetStringValue(object value)
        {
            if (value == DBNull.Value)
            {
                return(null);
            }
            var array = (byte[])value;

            if (array.Length <= 0)
            {
                return(string.Empty);
            }

            using (var ms = new MemoryStream(array))
            {
                var sqlXml = new SqlXml(ms);
                return(sqlXml.Value);
            }
        }
Beispiel #26
0
        private static void PutXml(WebRequest request, SqlXml xml, NameValueCollection attributes)
        {
            var wrs = new XmlWriterSettings()
            {
                Encoding = request.ContentType != null?GetContentEncoding(request.ContentType) : SqlRuntime.WebEncoding,
                               CloseOutput = true
            };

            if (attributes != null)
            {
                SetProperties(wrs, attributes, WriterPrefix);
            }
            using (var xrd = xml.CreateReader())
                using (var xwr = XmlWriter.Create(request.GetRequestStream(), wrs))
                {
                    xwr.WriteNode(xrd, true);
                    xwr.Flush();
                }
        }
Beispiel #27
0
    public static System.Collections.IEnumerable XmlToTable(SqlXml xml, string root)
    {
        List <xmlToTable.paraVlues> pvList = new List <xmlToTable.paraVlues>();
        int count = 1;

        if (!xml.IsNull)
        {
            try
            {
                XmlDocument doc = new XmlDocument();

                doc.LoadXml(xml.Value);
                var list = doc.GetElementsByTagName(root);
                if (list != null && list.Count > 0)
                {
                    for (int i = 0; i < list.Count; i++)
                    {
                        if (list[i].HasChildNodes)
                        {
                            for (int j = 0; j < list[i].ChildNodes.Count; j++)
                            {
                                var node = list[i].ChildNodes[j];
                                var pv   = new xmlToTable.paraVlues()
                                {
                                    id = count++, name = node.Name, value = node.InnerText
                                };
                                pvList.Add(pv);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                pvList.Add(new xmlToTable.paraVlues()
                {
                    id = count++, name = "error", value = ex.Message
                });
            }
        }
        // 在此处放置代码
        return(pvList);
    }
Beispiel #28
0
        public void TestGetSqlXmlReader(TestCaseResult result)
        {
            InsertRowText();

            VirtuosoCommand cmd = connection.CreateCommand();

            cmd.CommandText = "select data from xmlt";

            VirtuosoDataReader rdr = cmd.ExecuteReader();

            rdr.Read();
            SqlXml x = rdr.GetSqlXml(0);

            XmlDocument doc = new XmlDocument();

            doc.Load(x.CreateReader());

            FailIfXmlNotEqual(result, doc.OuterXml, TheXml);
        }
Beispiel #29
0
        public static XmlDocument GetXmlDocument(this IDataRecord record, string columnName)
        {
            SqlDataReader reader = record as SqlDataReader;

            XmlDocument document = new XmlDocument();

            if (reader != null)
            {
                SqlXml sqlXml = reader.GetSqlXml(record.GetOrdinal(columnName));

                using (XmlReader xmlReader = sqlXml.CreateReader())
                {
                    document.Load(xmlReader);

                    return(document);
                }
            }

            return(document);
        }
Beispiel #30
0
	public static int SqlSafeExecute( SqlString sqlcmd, SqlXml values ){
		int			n = 0;
		SqlConnection	conn = new SqlConnection("context connection=true");
		SqlCommand		cmd = new SqlCommand(sqlcmd.ToString(), conn);
		conn.Open();
		cmd.CommandType = CommandType.Text;
		cmd.CommandTimeout = 0;

		n=SqlSafeParmsEx( ref cmd, values );
		try{
			n = cmd.ExecuteNonQuery();
		}
		catch (Exception ed){
			throw new Exception(ed.Message + "\n" +
					@sqlcmd.ToString() );
//					xnav.SelectSingleNode(string.Format("/values/value[{0}]", 19)).Value);
		}
		conn.Close();
		return n;
	}//end SqlSafeExecute
Beispiel #31
0
        public void TestInsertSqlXml(TestCaseResult result)
        {
            VirtuosoCommand insert = connection.CreateCommand();

            insert.CommandText = "insert into xmlt (id, data) values (1, ?)";
            insert.Parameters.Add(new VirtuosoParameter(":0", new SqlXml(TheXml)));
            insert.ExecuteNonQuery();
            insert.Dispose();

            VirtuosoCommand cmd = connection.CreateCommand();

            cmd.CommandText = "select data from xmlt";

            VirtuosoDataReader rdr = cmd.ExecuteReader();

            rdr.Read();
            SqlXml x = rdr.GetSqlXml(0);

            FailIfXmlNotEqual(result, x.ToString(), TheXml);
        }
Beispiel #32
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="document"></param>
        /// <returns></returns>
        SqlXml XmlDocumentToSqlXml(XmlDocument document)
        {
            var _sqlXml = (SqlXml)null;

            if (document.HasChildNodes)
            {
                using (var _reader = new XmlNodeReader(document))
                {
                    if (!_reader.IsEmptyElement)
                    {
                        _sqlXml = new SqlXml(_reader);
                    }

                    _reader.Close();
                    _reader.Dispose();
                }
            }

            return(_sqlXml);
        }
Beispiel #33
0
        public static SqlXml Evaluate([SqlFacet(MaxSize = -1)] SqlXml input, [SqlFacet(MaxSize = -1)] SqlString path, SqlString nsMap)
        {
            if (input.IsNull || path.IsNull)
            {
                return(SqlXml.Null);
            }

            using (var reader = input.CreateReader())
            {
                var navigator = new XPathDocument(reader).CreateNavigator();
                var resolver  = GetNamespaceResolver(navigator.NameTable, !nsMap.IsNull ? nsMap.Value : null);
                var iterator  = navigator.Evaluate(XPathExpression.Compile(path.Value, resolver)) as XPathNodeIterator;
                if (iterator == null)
                {
                    return(SqlXml.Null);
                }
                var result = iterator.Cast <XPathNavigator>().SingleOrDefault();
                return(result != null ? new SqlXml(result.ReadSubtree()) : SqlXml.Null);
            }
        }
        public void SqlTypes_SqlXml ()
        {
            NpgsqlParameter parameter;
            SqlXml value = new SqlXml (new XmlTextReader (new StringReader ("<test>Mono</test>")));

            parameter = new NpgsqlParameter ();
            parameter.NpgsqlValue = value;
            Assert.AreEqual (NpgsqlDbType.Xml, parameter.NpgsqlDbType, "#A:NpgsqlDbType");
            Assert.AreSame (value, parameter.NpgsqlValue, "#A:NpgsqlValue");
            Assert.AreSame (value, parameter.Value, "#A:Value");

            parameter = new NpgsqlParameter ();
            parameter.NpgsqlValue = SqlXml.Null;
            Assert.AreEqual (NpgsqlDbType.Xml, parameter.NpgsqlDbType, "#B:NpgsqlDbType");
            Assert.IsNotNull (parameter.NpgsqlValue, "#B:SqlValue1");
            Assert.AreEqual (typeof (SqlXml), parameter.NpgsqlValue.GetType (), "#B:SqlValue2");
            Assert.IsTrue (((SqlXml) parameter.NpgsqlValue).IsNull, "#B:SqlValue3");
            Assert.IsNotNull (parameter.Value, "#B:Value1");
            Assert.AreEqual (typeof (SqlXml), parameter.Value.GetType (), "#B:Value2");
            Assert.IsTrue (((SqlXml) parameter.Value).IsNull, "#B:Value3");

            parameter = new NpgsqlParameter ();
            parameter.Value = value;
            Assert.AreEqual (NpgsqlDbType.Xml, parameter.NpgsqlDbType, "#C:NpgsqlDbType");
            Assert.AreSame (value, parameter.NpgsqlValue, "#C:NpgsqlValue");
            Assert.AreSame (value, parameter.Value, "#C:Value");
        }
 public void AddXml(SqlString name, SqlXml value)
 {
     base.AddParam(name, value);
 }
		internal override object ConvertValue (object value)
		{
		        object ret = null;
			Debug.WriteLineIf (CLI.FnTrace.Enabled, "BufferTypeSqlXml.ConvertValue (" + value + ")");
		        if (value is string)
			  ret = new SqlXml ((string) value);
			else if (value is XmlReader)
			  ret = new SqlXml ((XmlReader) value);
			else
			  ret = base.ConvertValue (value);
			return ret;
		}