public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList ) { DBO.VDM_VCMSLevelDBO dbo = new VDM_VCMSLevelDBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.ALL: Dt = dbo.doQueryAll(); break; case QueryType.CODE: Dt = dbo.doQueryByCode(ParameterList); break; case QueryType.ID: Dt = dbo.doQueryByID(ParameterList); break; case QueryType.Custom: Dt = dbo.doQueryByFind(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
/// <summary> /// Build data query from the specified <paramref name="queryType"/> /// </summary> /// <param name="queryType"> /// The query type. /// </param> /// <param name="structureRetrievalManager"> /// The structure retrieval manager. /// </param> /// <returns> /// The data query from the specified <paramref name="queryType"/> /// </returns> public IList<IDataQuery> BuildDataQuery( QueryType queryType, ISdmxObjectRetrievalManager structureRetrievalManager) { IList<IDataQuery> returnList = new List<IDataQuery>(); foreach (DataWhereType dataWhere in queryType.DataWhere) { // TODO java 0.9.9 no support for default limit. Opened : http://www.metadatatechnology.com/mantis/view.php?id=1427 DataQueryProcessor dataQueryProcessor = null; if (queryType.defaultLimit.HasValue && queryType.defaultLimit.Value < int.MaxValue) { int limit = decimal.ToInt32(queryType.defaultLimit.Value); dataQueryProcessor = new DataQueryProcessor(limit); } else { dataQueryProcessor = new DataQueryProcessor(); } returnList.Add(dataQueryProcessor.BuildDataQuery(dataWhere, structureRetrievalManager)); } return returnList; }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { #region VDS_ALO_DISRECORD_TMP_DBO ALOM = new VDS_ALO_DISRECORD_TMP_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.GetDISRECORD_TmpSchema: Dt = ALOM.GetDISRECORD_TmpSchema(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw GetNewException(ex); } #endregion }
public Table(string com, NpgsqlConnection con, QueryType t = QueryType.Select) { command = com; connection = con; type = t; }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList ) { DBO.RemoveDataDetail dbo = new RemoveDataDetail(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.ALL: Dt = dbo.doQueryAll(); break; case QueryType.ID: Dt = dbo.doQueryByID(ParameterList); break; case QueryType.Custom: Dt = dbo.doQueryByFind(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList ) { DBO.SYS_OrganizationDBO Organization = new SYS_OrganizationDBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.ALL: Dt = Organization.doQueryAll(); break; case QueryType.CODE: Dt = Organization.doQueryByCode(ParameterList); break; case QueryType.ID: Dt = Organization.doQueryByID(ParameterList); break; case QueryType.Custom: Dt = Organization.doQueryByFind(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList ) { DBO.MKT_PurchaseCardNondissStDBO dbo = new MKT_PurchaseCardNondissStDBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.ALL: Dt = dbo.doQueryAll(); break; case QueryType.ID: Dt = dbo.doQueryByID(ParameterList); break; case QueryType.Custom: Dt = dbo.doQueryByFind(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public void QueryLog(IQueryable linqQuery) { _querytype = QueryType.LINQ; _linqQuery = linqQuery.Expression.ToString(); _StoreSQL = ToTraceString(linqQuery); CreateLogEntry(); }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { #region VDS_ALO_POSOURCE_NO_TMP_DBO ALOM = new VDS_ALO_POSOURCE_NO_TMP_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.CheckCurrentItemStatus: Dt = ALOM.doCheckCurrentItemStatus(ParameterList); break; case QueryType.GetPOSOURCE_NO_TmpSchema: Dt = ALOM.GetPOSOURCE_NO_TmpSchema(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw GetNewException(ex); } #endregion }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { #region VDS_CRM_ORDER_TMP_DBO CRM_DBO = new VDS_CRM_ORDER_TMP_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.GetCRMOrder_TmpSchema: Dt = CRM_DBO.GetORDER_TmpSchema(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw GetNewException(ex); } #endregion }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { DBO.VDS_CRM_RECORD_MAINDBO VCRM = new VDS_CRM_RECORD_MAINDBO(ref USEDB); DBO.VDS_CRM_RECORD_DETLDBO VCRD = new VDS_CRM_RECORD_DETLDBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.QueryLastThreeCRMRecord: Dt = VCRM.DO_CRM011_QUERY_RECORD_THREE(ParameterList); break; case QueryType.CRM011_DETL_SCHEMA: Dt = VCRD.DO_CRM011_DETAIL_SCHEMA(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw GetNewException(ex); } }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList ) { DBO.SYS_ROLEPROGAUTHRELDBO RoleProgauthrel = new SYS_ROLEPROGAUTHRELDBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.ALL: Dt = RoleProgauthrel.doQueryAll(); break; case QueryType.CODE: Dt = RoleProgauthrel.doQueryByCode(ParameterList); break; case QueryType.ID: Dt = RoleProgauthrel.doQueryByID(ParameterList); break; case QueryType.Custom: Dt = RoleProgauthrel.doQueryByFind(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public Query(QueryType type, long token, ReqlAst term, OptArgs globalOptions) { this.Type = type; this.Token = token; this.Term = term; this.GlobalOptions = globalOptions; }
/// <summary> /// 查询类型转化成字符串 /// </summary> /// <param name="type">查询类型</param> /// <returns>查询类型字符串</returns> public static string QueryTypeToString(QueryType type) { string s = "INSURANCE"; switch (type) { case QueryType.INSURANCE: s = "INSURANCE"; break; case QueryType.QEONYCARD: s = "QEONYCARD"; break; case QueryType.ASSET: s = "ASSET"; break; case QueryType.NETSITE: s = "NETSITE"; break; case QueryType.EXCHANGE_CH: s = "EXCHANGE_CH"; break; case QueryType.EXCHANGE_EN: s = "EXCHANGE_EN"; break; default: s = "INSURANCE"; break; } return s; }
/// <summary> /// Creates a LinqLambdaType given the body type and parameter types. /// </summary> /// <param name="bodyType">Type of the lambda body.</param> /// <param name="parameterTypes">Collection of lambda parameter types.</param> /// <returns>LinqLambdaType with given body and parameter types.</returns> public static LinqLambdaType Lambda(QueryType bodyType, IEnumerable<QueryType> parameterTypes) { ExceptionUtilities.CheckArgumentNotNull(bodyType, "bodyType"); ExceptionUtilities.CheckArgumentNotNull(parameterTypes, "parameterTypes"); return new LinqLambdaType(bodyType, parameterTypes, bodyType.EvaluationStrategy); }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList ) { DBO.PUR_PurchaseOrderDBO dbo = new PUR_PurchaseOrderDBO(ref USEDB); DataTable Dt; try { switch (QT) { //case QueryType.ALL: // Dt = dbo.doQueryAll(); // break; //case QueryType.CODE: // Dt = dbo.doQueryByCode(ParameterList); // break; case QueryType.PK: Dt = dbo.GetMasterByPK(ParameterList); break; case QueryType.Where1: Dt = dbo.GetMainByWhere1(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
/// <summary> /// Инициализирует новый запрос /// </summary> /// <param name="type">Тип запроса</param> /// <param name="sql">Текст запроса</param> /// <param name="storedProcedure">Является ли хранимой процедурой</param> /// <param name="parameters">Параметры запроса</param> public Query(QueryType type, string sql, bool storedProcedure, params DbParam[] parameters) { Sql = sql; Parameters = parameters; Type = type; StoredProcedure = storedProcedure; }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { DBO.VDS_CGD36M_DBO CodeFileM = new VDS_CGD36M_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.CODE: Dt = CodeFileM.doQueryByCode(ParameterList); break; case QueryType.ID: Dt = CodeFileM.doQueryByID(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public static Uri BuildQuery(QueryType type,string url,string query) { UriBuilder bldr = new UriBuilder(url); switch (type) { case QueryType.Search: string restQuery = ""; if (url.EndsWith("/") != true) { restQuery = "/"; } restQuery += "_api/search/query"; bldr.Path += restQuery; bldr.Query = "querytext='" + query + "'"; break; case QueryType.Lists: break; default: break; } return bldr.Uri; }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList ) { VDS_ALO_DIS_PATTERN_DBO ALOM = new VDS_ALO_DIS_PATTERN_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.ALL: Dt = ALOM.doQueryAll(); break; case QueryType.CODE: Dt = ALOM.doQueryByCode(ParameterList); break; case QueryType.ID: Dt = ALOM.doQueryByID(ParameterList); break; case QueryType.Custom: Dt = ALOM.doQueryByFind(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw GetNewException(ex); } }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { CGD.VDS_CGD_PICK_LIST_PRINT_DBO CGDM = new VDS_CGD_PICK_LIST_PRINT_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.REPORT: Dt = CGDM.QueryPickList(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { CGD.VDS_CGD41_DBO CGDM = new VDS_CGD41_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.GetPickBatch: Dt = CGDM.GetPickBatch(ParameterList); break; case QueryType.Label: Dt = CGDM.ExpLabelData(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { // CGD.VDS_ALO_ST_ACCEPT_MAIN_DBO CGDM = new VDS_ALO_ST_ACCEPT_MAIN_DBO(ref USEDB); CGD.VDS_CGD07_DBO CGDM = new VDS_CGD07_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.GetAloItemSumQty: Dt = CGDM.GetAloItemSumQty(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
/// <summary> /// Get IPHostEntry for given domainName. /// </summary> /// <param name="domainName">domainName</param> /// <param name="queryType">QueryType.Address or QueryType.MailExchange</param> /// <param name="dnsServers">dnsServers</param> /// <returns></returns> public static IPHostEntry GetIPHostEntry(string domainName, QueryType queryType, string[] dnsServers) { if (String.IsNullOrEmpty(domainName)) { throw new ArgumentException("Domain name is empty.", "domainName"); } DnsServers.Clear(); if (dnsServers != null) { foreach (string dnsServer in dnsServers) { DnsServers.Add(IPAddress.Parse(dnsServer)); } } DnsServers.AddRange(RootDnsServers); int retry = 0; while (retry < 10) { foreach (IPAddress dnsServer in DnsServers) { IPHostEntry ip = GetIPHostEntry(domainName, queryType, dnsServer); if (ip != null) { return ip; } } retry++; } return null; }
public DataTable QuerySwitchLine(QueryType QT, ArrayList ParameterList) { DBO.VDS_ITM_PERIOD_MAIN_DBO STDM = new VDS_ITM_PERIOD_MAIN_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.ITEM_PERIOD: Dt = STDM.doQueryByFind(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public SQLWriter(Servers server, QueryType queryType, String tableName, int buffSize = 100) { m_queryType = queryType; m_buffSize = buffSize; m_server = server; m_tableName = tableName; }
/// <summary> /// Initializes a new instance of the <see cref="QueryBuilder"/> class. /// </summary> /// <param name="type">The requested <see cref="QueryType"/>.</param> internal QueryBuilder(QueryType type) { this.type = type; builder = new StringBuilder(); Init(); }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { DBO.STD_IMPORT_DBO STDM = new STD_IMPORT_DBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.CHAN_NO: Dt = STDM.doQueryByChanNo(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw ex; } }
public string StQuerySwitch(QueryType QT, ArrayList ParameterList, out string errMsg) { CGD.VDS_CGD23_DBO CGDM = new VDS_CGD23_DBO(ref USEDB); string str; string ErrMsg = ""; try { switch (QT) { case QueryType.GetMaxPickBatch: str = CGDM.GetMaxPickBatch(ParameterList, out ErrMsg); errMsg = ErrMsg; break; case QueryType.GetCheckBatch: str = CGDM.GetCheckBatch(ParameterList, out ErrMsg); errMsg = ErrMsg; break; default: str = ""; errMsg = ""; break; } return str; } catch (Exception ex) { throw ex; } }
public DataTable QuerySwitch(QueryType QT, ArrayList ParameterList) { DBO.VDS_CRM_MESSAGEDBO VCM = new VDS_CRM_MESSAGEDBO(ref USEDB); DataTable Dt; try { switch (QT) { case QueryType.QueryCRMMessageByFind: Dt = VCM.DO_CRM011_QUERY_MESSAGE(ParameterList); break; default: Dt = new DataTable(); break; } return Dt; } catch (Exception ex) { throw GetNewException(ex); } }
internal LinqContainsExpression(QueryExpression source, QueryExpression value, QueryType type) : base(source, type) { this.Value = value; }
public async Task <GeoLookupResponse> GetGeoLookupAsync(QueryType queryType, QueryOptions options = null) { Service <GeoLookupResponse> forecast = new Service <GeoLookupResponse>(_apiKey, _baseUrl); return(await forecast.GetDataAsync(Feature.GeoLookup, queryType, options).ConfigureAwait(false)); }
public GeoLookupResponse GetGeoLookup(QueryType queryType, QueryOptions options = null) { Service <GeoLookupResponse> forecast = new Service <GeoLookupResponse>(_apiKey, _baseUrl); return(forecast.GetData(Feature.GeoLookup, queryType, options)); }
public void ReqQuery(string type) { QueryType obj = Enum <QueryType> .Parse(type); api.ReqQuery(obj, ref _Query); }
/// <summary> /// 根据日期间隔取得记录 /// </summary> /// <param name="startDate">起始日期(包含起始日期)</param> /// <param name="endDate">终止日期(包含终止日期)</param> /// <param name="recordTypeId">要查询的记录类型,不限制请传入0</param> /// <param name="queryType">查询类型</param> /// <returns>取得的记录集</returns> public IList <Record> GetByDate(DateTime startDate, DateTime endDate, int recordTypeId, QueryType queryType) { if (startDate.Date > endDate.Date && startDate.Year > DateTime.Now.Year && queryType == null) { return(null); } IList <string> dataFileList = new List <string>(); IList <Record> recordList = new List <Record>(); if (queryType == QueryType.年单位) { int iCount = (endDate.Year - startDate.Year + 1) * 12; DateTime QuerySDate = new DateTime(startDate.Year, 1, 1); for (int i = 0; i <= iCount; i++) { dataFileList.Add(System.Environment.CurrentDirectory + "\\Data\\" + QuerySDate.AddMonths(i).ToString(@"yyyy/MM") + ".xml"); } } else if (queryType == QueryType.月单位 || queryType == QueryType.日单位) { int iCount = startDate.Year == endDate.Year ? endDate.Month - startDate.Month : (12 - startDate.Month + 1) + (endDate.Year - startDate.Year - 1) * 12 + endDate.Month; for (int i = 0; i <= iCount; i++) { dataFileList.Add(System.Environment.CurrentDirectory + "\\Data\\" + startDate.AddMonths(i).ToString(@"yyyy/MM") + ".xml"); } } XmlOperate op = new XmlOperate(dataFileList, XmlFileOpType.创建, startDate); IList <XmlDocument> doclist = op.GetList(); if (queryType == QueryType.年单位 || queryType == QueryType.月单位) { XmlNodeList tempList = null; if (recordTypeId == 0) { foreach (XmlDocument item in doclist) { tempList = item.DocumentElement.ChildNodes; foreach (XmlElement node in tempList) { recordList.Add(Get(node)); } } } else { foreach (XmlDocument item in doclist) { tempList = item.DocumentElement.ChildNodes; Record record = null; foreach (XmlElement node in tempList) { record = Get(node); if (CheckTpye(recordTypeId, record.Type)) { recordList.Add(record); } } } } } else //queryType == QueryType.日单位 { XmlNodeList tempList = null; if (recordTypeId == 0) { foreach (XmlDocument item in doclist) { tempList = item.DocumentElement.ChildNodes; Record record = null; foreach (XmlElement node in tempList) { record = Get(node); if (record.Date.Date >= startDate.Date && record.Date.Date <= endDate.Date) { recordList.Add(Get(node)); } } } } else { foreach (XmlDocument item in doclist) { tempList = item.DocumentElement.ChildNodes; Record record = null; foreach (XmlElement node in tempList) { record = Get(node); if (record.Date.Date >= startDate.Date && record.Date.Date <= endDate.Date && CheckTpye(recordTypeId, record.Type)) { recordList.Add(Get(node)); } } } } } return(recordList); }
protected void PrintResults(IEnumerable <int> bits, Func <int, int> questionLookup, string info, QueryType queryType) { Logger.Log("RESULTS for \"{0}\":", info); var fieldFetcher = GetFieldSelector(queryType); foreach (var bit in bits.Take(10)) { var questionId = questionLookup == null ? bit : questionLookup(bit); var question = questions[questionId]; Logger.Log(" Bit=[{0,9:N0}] -> Qu=[{1,9:N0}], {2}={3,10}, Tags= {4}", bit, questionId, queryType, fieldFetcher(question), String.Join(", ", question.Tags)); } }
public void Query(QueryType type, ReqQueryField query) { _api.Query(type, query); }
public void Query(QueryType type, ReqQueryField query) { _client?.Query(type, query); }
/// <summary> /// Attempts a lookup from DNS. /// </summary> /// <param name="uri"></param> /// <param name="startQuery"></param> /// <param name="preferIPv6"></param> /// <param name="ct"></param> /// <returns></returns> private static async Task <SIPEndPoint> SIPLookupAsync( SIPURI uri, QueryType startQuery, bool preferIPv6, CancellationToken ct) { SIPEndPoint result = null; QueryType queryType = startQuery; string host = uri.MAddrOrHostAddress; int port = SIPConstants.GetDefaultPort(uri.Protocol); if (ushort.TryParse(uri.HostPort, out var uriPort)) { port = uriPort; } bool isDone = false; while (!isDone && !ct.IsCancellationRequested) { switch (queryType) { case QueryType.SRV: try { var srvProtocol = SIPServices.GetSRVProtocolForSIPURI(uri); //string serviceHost = DnsQueryExtensions.ConcatResolveServiceName(uri.MAddrOrHostAddress, uri.Scheme.ToString(), srvProtocol.ToString()); //var srvResult = await _lookupClient.QueryAsync(serviceHost, QueryType.SRV, QueryClass.IN, ct).ConfigureAwait(false); var srvResult = await _lookupClient.ResolveServiceAsync(uri.MAddrOrHostAddress, uri.Scheme.ToString(), srvProtocol.ToString()); (var srvHost, var srvPort) = GetHostAndPortFromSrvResult(srvResult); if (srvHost != null) { host = srvHost; port = srvPort != 0 ? srvPort : port; } } catch (Exception srvExcp) { logger.LogWarning($"SIPDNS exception on SRV lookup. {srvExcp.Message}."); } queryType = preferIPv6 ? QueryType.AAAA : QueryType.A; break; case QueryType.AAAA: try { var aaaaResult = await _lookupClient.QueryAsync(host, UseANYLookups?QueryType.ANY : QueryType.AAAA, QueryClass.IN, ct).ConfigureAwait(false); if (aaaaResult?.Answers?.Count > 0) { result = GetFromLookupResult(uri.Protocol, aaaaResult.Answers.AddressRecords().OrderByDescending(x => x.RecordType).First(), port); isDone = true; } else { queryType = QueryType.A; } } catch (Exception srvExcp) { logger.LogWarning($"SIPDNS exception on AAAA lookup. {srvExcp.Message}."); queryType = QueryType.A; } break; default: // A record lookup. try { var aResult = await _lookupClient.QueryAsync(host, QueryType.A, QueryClass.IN, ct).ConfigureAwait(false); if (aResult != null) { if (aResult.Answers?.Count > 0) { result = GetFromLookupResult(uri.Protocol, aResult.Answers.AddressRecords().First(), port); } else { // We got a result back but it was empty indicating an unresolvable host or // some other DNS error condition. result = SIPEndPoint.Empty; } } } catch (Exception srvExcp) { logger.LogWarning($"SIPDNS exception on A lookup. {srvExcp.Message}."); result = SIPEndPoint.Empty; } isDone = true; break; } } return(result); }
/// <summary> /// Attempts a lookup from cache. /// </summary> /// <param name="uri"></param> /// <param name="startQuery"></param> /// <param name="preferIPv6"></param> /// <returns></returns> private static SIPEndPoint SIPLookupFromCache( SIPURI uri, QueryType startQuery, bool preferIPv6) { CancellationTokenSource cts = new CancellationTokenSource(); return(SIPLookupAsync(uri, startQuery, preferIPv6, cts.Token).Result); // TODO: Re-enable when DnsClient adds cache querying. //SIPEndPoint result = null; //QueryType queryType = startQuery; //string host = uri.MAddrOrHostAddress; //int port = SIPConstants.GetDefaultPort(uri.Protocol); //if (ushort.TryParse(uri.HostPort, out var uriPort)) //{ // port = uriPort; //} //bool isDone = false; //while (!isDone) //{ // switch (queryType) // { // case QueryType.SRV: // var srvProtocol = SIPServices.GetSRVProtocolForSIPURI(uri); // string serviceHost = DnsQueryExtensions.ConcatResolveServiceName(uri.MAddrOrHostAddress, uri.Scheme.ToString(), srvProtocol.ToString()); // var srvResult = _lookupClient.QueryCache(serviceHost, QueryType.SRV); // (var srvHost, var srvPort) = GetHostAndPortFromSrvResult(srvResult); // if (srvHost != null) // { // host = srvHost; // port = srvPort != 0 ? srvPort : port; // } // queryType = preferIPv6 ? QueryType.AAAA : QueryType.A; // break; // case QueryType.AAAA: // var aaaaResult = _lookupClient.QueryCache(host, UseANYLookups ? QueryType.ANY : QueryType.AAAA, QueryClass.IN); // if (aaaaResult?.Answers?.Count > 0) // { // result = GetFromLookupResult(uri.Protocol, aaaaResult.Answers.OrderByDescending(x => x.RecordType).First(), port); // isDone = true; // } // else // { // queryType = QueryType.A; // } // break; // default: // // A record lookup. // var aResult = _lookupClient.QueryCache(host, QueryType.A, QueryClass.IN); // if (aResult != null) // { // if (aResult.Answers?.Count > 0) // { // result = GetFromLookupResult(uri.Protocol, aResult.Answers.First(), port); // } // else // { // // We got a result back but it was empty indicating an unresolvable host or // // some other DNS error condition. // result = SIPEndPoint.Empty; // } // } // isDone = true; // break; // } //} //return result; }
/// <summary>To be documented.</summary> public static unsafe void CmdWriteAccelerationStructuresProperties(this NVRayTracing thisApi, [Count(Count = 0)] CommandBuffer commandBuffer, [Count(Count = 0)] uint accelerationStructureCount, [Count(Parameter = "accelerationStructureCount"), Flow(FlowDirection.In)] ReadOnlySpan <AccelerationStructureNV> pAccelerationStructures, [Count(Count = 0)] QueryType queryType, [Count(Count = 0)] QueryPool queryPool, [Count(Count = 0)] uint firstQuery) { // SpanOverloader thisApi.CmdWriteAccelerationStructuresProperties(commandBuffer, accelerationStructureCount, in pAccelerationStructures.GetPinnableReference(), queryType, queryPool, firstQuery); }
public void FailToParseInvalidJavascript(string q, QueryType type) { Assert.Throws <InvalidQueryException>(() => new QueryMetadata(q, null, 1, queryType: type)); }
private object GetParameters(object item, QueryType queryType = QueryType.Update) { if (item is Platform) { var objItem = item as Platform; switch (queryType) { case QueryType.Add: return(new { Name = objItem.Name, Description = objItem.Description }); case QueryType.Update: return(new { Id = objItem.Id, Name = objItem.Name, Description = objItem.Description }); case QueryType.Delete: return(new { Id = objItem.Id }); } } else if (item is KnowledgeArea) { var objItem = item as KnowledgeArea; switch (queryType) { case QueryType.Add: return(new { PlatformId = objItem.PlatformId, Name = objItem.Name, Description = objItem.Description }); case QueryType.Update: return(new { Id = objItem.Id, Name = objItem.Name, Description = objItem.Description }); case QueryType.Delete: return(new { Id = objItem.Id }); } } if (item is Area) { var objItem = item as Area; switch (queryType) { case QueryType.Add: return(new { KnowledgeAreaId = objItem.KnowledgeAreaId, Name = objItem.Name, Description = objItem.Description }); case QueryType.Update: return(new { Id = objItem.Id, Name = objItem.Name, Description = objItem.Description }); case QueryType.Delete: return(new { Id = objItem.Id }); } } if (item is Question) { var objItem = item as Question; switch (queryType) { case QueryType.Add: return(new { AreaId = objItem.AreaId, Value = objItem.Value, Weight = objItem.Weight, Level = objItem.Level }); case QueryType.Update: return(new { Id = objItem.Id, Value = objItem.Value, Weight = objItem.Weight, Level = objItem.Level }); case QueryType.Delete: return(new { Id = objItem.Id }); } } return(null); }
// 返回查询结果 public object getQueryResult(QueryType queryType) { QueryMgr mgr = getSys <QueryMgr>(SysType.sysTypeQuery); return(mgr.getQueryResult(queryType)); }
internal LinqBitwiseOrExpression(QueryExpression left, QueryExpression right, QueryType type) : base(left, right, type) { }
private static void ProcessCommandlineArguments(IEnumerable <string> args) { foreach (var arg in args) { switch (arg.ToLowerInvariant()) { case @"u": case @"uninstall": if (_queryType != QueryType.None) { throw new FormatException(@"Multiple commands specified"); } _queryType = QueryType.Uninstall; break; case @"i": case @"info": if (_queryType != QueryType.None) { throw new FormatException(@"Multiple commands specified"); } _queryType = QueryType.GetInfo; break; case @"/s": case @"/silent": if (_queryType != QueryType.Uninstall) { throw new FormatException(@"/silent must follow the uninstall command"); } _silent = true; break; case @"l": case @"list": if (_queryType != QueryType.None) { throw new FormatException(@"Multiple commands specified"); } _queryType = QueryType.List; break; case @"steam": if (_queryType != QueryType.None) { throw new FormatException(@"Multiple commands specified"); } _queryType = QueryType.SteamDir; break; default: if (_appId != default(int)) { throw new FormatException(@"Multiple AppIDs specified"); } if (!int.TryParse(arg, out _appId)) { throw new FormatException($@"Unknown argument: {arg}"); } break; } } if (_queryType == QueryType.None) { throw new FormatException(@"No commands specified"); } if (_queryType != QueryType.List && _queryType != QueryType.SteamDir && _appId == default(int)) { throw new FormatException(@"No AppID specified"); } }
/// <summary> /// Initializes a new instance of the QueryTypeOperationExpression class. /// </summary> /// <param name="source">The root argument of the expression.</param> /// <param name="typeToOperateAgainst">The type to covert to.</param> /// <param name="type">The type of expression.</param> protected QueryTypeOperationExpression(QueryExpression source, QueryType typeToOperateAgainst, QueryType type) : base(type) { this.Source = source; this.TypeToOperateAgainst = typeToOperateAgainst; }
/// <summary> /// <para>WARNING: THIS FUNCTION IS NOT YET HOOKED UP.</para> /// <para>Gets all tasks which match a specified query.</para> /// </summary> /// <param name="query">The query string.</param> /// <param name="type">The type of query to perform.</param> /// <returns></returns> public static UserTask[] Query(string query, QueryType type) { throw (new NotImplementedException()); }
public Query(string situation, string question, string explaination, Answer[] answers, QueryType type) { this.situation = situation; this.question = question; this.explaination = explaination; this.answers = answers; this.type = type; }
public IQuery CreateQuery( string id, StorageProviderDefinition storageProviderDefinition, string statement, CommandParameter[] commandParameters, QueryType queryType) { IQuery query = Next.CreateQuery(id, storageProviderDefinition, statement, commandParameters, queryType); QueryConstructed(query); return(query); }
/// <summary> /// Initializes a new instance of the <see cref="QueryDescription"/> struct. /// </summary> /// <param name="queryType">Type of query (see <see cref="QueryType"/>).</param> /// <param name="miscFlags">Miscellaneous flags (see <see cref="QueryFlags"/>).</param> public QueryDescription(QueryType queryType, QueryFlags miscFlags = QueryFlags.None) { QueryType = queryType; MiscFlags = miscFlags; }
QueryItemEvent(QueryType subType) { QueryType = subType; }
/// <summary> /// Attempts to resolve a hostname. /// </summary> /// <param name="host">The hostname to resolve.</param> /// <param name="port">The service port to use in the end pint result (not used for the lookup).</param> /// <param name="queryType">The lookup query type, either A or AAAA.</param> /// <returns>If successful an IPEndPoint or null if not.</returns> private static SIPEndPoint HostQuery(SIPProtocolsEnum protocol, string host, int port, QueryType queryType) { try { var addrRecord = _lookupClient.Query(host, queryType).Answers.FirstOrDefault(); if (addrRecord != null) { return(GetFromLookupResult(protocol, addrRecord, port)); } } catch (Exception excp) { logger.LogWarning($"SIP DNS lookup failure for {host} and query {queryType}. {excp.Message}"); } if (queryType == QueryType.AAAA) { return(HostQuery(protocol, host, port, QueryType.A)); } return(null); }
internal QueryEqualToExpression(QueryExpression left, QueryExpression right, QueryType type) : base(left, right, type) { }
/// <summary> /// Resolve method that performs either an A or AAAA record lookup. If required /// a SRV record lookup will be performed prior to the A or AAAA lookup. /// </summary> /// <param name="uri">The SIP URI to lookup.</param> /// <param name="queryType">Whether the address lookup should be A or AAAA.</param> /// <returns>A SIPEndPoint or null.</returns> private static async Task <SIPEndPoint> Resolve(SIPURI uri, QueryType queryType) { if (uri == null || String.IsNullOrWhiteSpace(uri.MAddrOrHostAddress)) { throw new ArgumentNullException("uri", "SIP DNS resolve was supplied an empty input."); } if (!ushort.TryParse(uri.HostPort, out var uriPort)) { uriPort = SIPConstants.DEFAULT_SIP_PORT; } if (IPAddress.TryParse(uri.MAddrOrHostAddress, out var ipAddress)) { // Target is already an IP address, no DNS lookup required. return(new SIPEndPoint(uri.Protocol, ipAddress, uriPort)); } else { if (!uri.MAddrOrHostAddress.Contains(".") || uri.MAddrOrHostAddress.EndsWith(MDNS_TLD)) { AddressFamily family = (queryType == QueryType.AAAA) ? AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork; // The lookup is for a local network host. Use the OS DNS logic as the // main DNS client can be configured to use external DNS servers that won't // be able to lookup this hostname. IPHostEntry hostEntry = null; try { hostEntry = Dns.GetHostEntry(uri.MAddrOrHostAddress); } catch (SocketException) { // Socket exception gets thrown for failed lookups, } if (hostEntry != null) { var addressList = hostEntry.AddressList; if (addressList?.Length == 0) { logger.LogWarning($"Operating System DNS lookup failed for {uri.MAddrOrHostAddress}."); return(null); } else { if (addressList.Any(x => x.AddressFamily == family)) { var addressResult = addressList.First(x => x.AddressFamily == family); return(new SIPEndPoint(uri.Protocol, addressResult, uriPort)); } else { // Didn't get a result for the preferred address family so just use the // first available result. var addressResult = addressList.First(); return(new SIPEndPoint(uri.Protocol, addressResult, uriPort)); } } } else { return(null); } } else { if (uri.HostPort != null) { // Explicit port means no SRV lookup. return(HostQuery(uri.Protocol, uri.MAddrOrHostAddress, uriPort, queryType)); } else { // No explicit port so use a SRV -> (A | AAAA -> A | ANY) record lookup. var srvProtocol = SIPServices.GetSRVProtocolForSIPURI(uri); try { ServiceHostEntry srvResult = null; var srvResults = await _lookupClient.ResolveServiceAsync(uri.MAddrOrHostAddress, uri.Scheme.ToString(), srvProtocol.ToString()).ConfigureAwait(false); if (srvResults == null || srvResults.Count() == 0) { logger.LogWarning($"SIP DNS SRV lookup returned no results for {uri}."); } else { srvResult = srvResults.OrderBy(y => y.Priority).ThenByDescending(w => w.Weight).FirstOrDefault(); } string host = uri.MAddrOrHostAddress; // If no SRV results then fallback is to lookup the hostname directly. int port = SIPConstants.DEFAULT_SIP_PORT; // If no SRV results then fallback is to use the default port. if (srvResult != null) { host = srvResult.HostName; port = srvResult.Port; } return(HostQuery(uri.Protocol, host, port, queryType)); } catch (Exception e) { logger.LogWarning($"SIP DNS SRV lookup failure for {uri}. {e?.InnerException?.Message}"); } } } return(null); } }
public FreeBusyApplication(ClientContext clientContext, FreeBusyViewOptions freeBusyView, bool defaultFreeBusyOnly, QueryType queryType) : base(true) { this.freeBusyView = freeBusyView; this.clientContext = clientContext; this.defaultFreeBusyOnly = defaultFreeBusyOnly; this.queryType = queryType; }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Initializes a new instance of the EmailMicroService.DnsQuery class. </summary> /// /// <param name="domainName"> Name of the domain. </param> /// <param name="qtype"> The qtype. </param> //////////////////////////////////////////////////////////////////////////////////////////////////// public DnsQuery(string domainName, QueryType qtype) { DomainName = domainName; QueryType = qtype; QueryClass = QueryClass.Internet; }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Initializes a new instance of the EmailMicroService.DnsQuery class. </summary> /// /// <param name="domainName"> Name of the domain. </param> /// <param name="qtype"> The qtype. </param> /// <param name="qclass"> The qclass. </param> //////////////////////////////////////////////////////////////////////////////////////////////////// public DnsQuery(string domainName, QueryType qtype, QueryClass qclass) { DomainName = domainName; QueryType = qtype; QueryClass = qclass; }
/// <summary> /// Initializes a new instance of the <see cref="QueryAttribute"/> class. /// </summary> /// <param name="queryType">Type of the query.</param> public QueryAttribute(QueryType queryType) { this.queryType = queryType; }
public DataLoaderTestSchema(IServiceProvider services, QueryType query, SubscriptionType subscriptionType) : base(new DependencyResolver(services)) { Query = query; Subscription = subscriptionType; }