Pattern to match all the possible variables in a SPARQL query. It was built on a negation class of the following characters: white spaces, newlines, punctuation (except for ?), closing parenthesis and double quotes.

Tokenizes a search query into individual parts: Group 1: Open Param Group 2: Close Param Group 3: Keyword Group 4: Value Group 5: Quoted Value Group 6: Regex Group 7: Regex Flag/Mod

Validation pattern to validate the minimum_should_mach value in opensearch and elasticsearch queries. For more information on the minimum_should_match field have a look here for opensearch or here for elasticsearch

diversitystars.com

IsHimMarketing.com

for JS regular expression to validate any http|https|ftp|IPv4 address, supported: authority username:password (example https://username:password@example.com); port :0-65565 (example https://example.com:80); query/queries ?c=1 or ?c=1&d=x (example https://example.com/main.php?c=1&d=x); fragment #name (example https://example.com/main.php#top); WaybackMachine URLs contains *;

A complete validation for GIT branch names. Includes typical branch names such as main and develop as well as feature, release branches and more. Examples: feat/add-i18n-module release/v1.0.0 main next/staging docs/fix-typo `bugfix/182/encode-slashes-in-url-query

Support any types of URL for https and http protocol. http or https [optional] domain name [mandatory] file path [optional] query parameter [optional]

A simple URL regex that can handle most "properly" formed URLs, and some URIs. It features named groups to easily destruct matches. URIs can use relative paths (../ and ./) to resources. Example (JavaScript) let url = "https://username:password@example.org:8080/path/to/resource?query=term&query=terms#fragment"; let regex = /{{ URL RegEx }}/i; let { href, origin, protocol, scheme, username, password, host, hostname, port, pathname, search, hash } = regex.exec(url).groups; // href → "https://username:password@example.org:8080/path/to/resource?query=term&query=terms#fragment" // origin → "https://" // protocol → "https:" // scheme → "https" // username → "username" // password → "password" // host → "example.org:8080" // hostname → "example.org" // port → "8080" // pathname → "/path/to/resource" // search → "?query=term&query=terms" // hash → "#fragment"

Validates protocol, sub-domain, domain, and top-level domain. No port number and query string parameters validation is made.

Get all table from sql query string | 从SQL查询语句中获取所有表名。 WelineFramework PHP8 。

Make sure http[s]:// uses two slashes, not one. IIS rewrite rules removes double slashes in the raw URL, breaking YOURLS (PHP) for example. This regexp changes all single slashes to double after a web protocol, including nested querystrings.

This pattern finds a parameter (sst) key + value in a GET request URL. When replaced with an empty string, effectively removes the parameter. Works with both full URLs and isolated query strings. Works in PCRE and PCRE2. Full use case: if (isset($_GET["sst"])) { // validate // modify active session $query = $_SERVER["REQUEST_URI"]; $pattern = "/(sst=+&)|((\?|&|^)sst=+$)/"; $uri = preg_replace($pattern, "", $query); unset($_GET["sst"]); header("location: https://example.com$uri", true, 308); }

Need to FULLY Break Out EVERY Component of a URL? Like, as in "every constituent element individually accessible in its own named capture group?" Need it to be pre-optimized and fully ECMA-compliant? Want to see exhaustive unit tests proving these claims (144 are included; all 144 execute in 6.5ms. Total.)? Then you just lucked out. What Does It Do? Fully breaks down a URL, acting the same (meaning the same capture group names apply regardless of use case; makes for MUCH easier interaction in ones code) on: Relative Paths (./, .//) Absolute Paths (/) Fully-qualified domains (https://www.domain.com/) Partially-qualified domains (https://domain.com/) Dynamically-protocol'd domains (//domain.com/) ...with each separated out into HOST, PROTOCOL, DOMAIN, and RELATIVE path prefix. BUT WAIT! THERE'S MORE! It then further proceeds to break out (also into individually-named groups, but only when present): URI Path (/some/path/to/a/file/) Full File Name, with or without Extension (filename.ext) File Name (filename) Extension (.ext) QueryString Parameters (?query=string) Anchor Tags/Routing (#SomeAnchor) Best of all, EVERY ONE of these are delivered in named capture groups (so you're looking at obj.groups.DOMAIN instead of object[3]) Examples: Fully-Qualified Domain Full Request: https://www.domain.com/some/path/to/a/file-with.ext?Plus=QueryString#AndAnchor Host: https://www.domain.com/ Protocol: https:// Domain: www.domain.com/ Path: some/path/to/a/ FullFileName: file-with.ext FileName: file-with Extension: .ext QueryString: ?Plus=QueryString Anchor: #AndAnchor Relative Path Full Request: ../../../../some/path/to/a/file-with.ext?Plus=QueryString#AndAnchor Relative: ../../../../ Path: some/path/to/a/ FullFileName: file-with.ext FileName: file-with Extension: .ext QueryString: ?Plus=QueryString Anchor: #AndAnchor

This works against a list of hyperlinks from the 'USS Marmora (1862)' article You can include File: pages by removing the File:| from the regex. I could improve how the remaining query for urls containing index.php, for now I recommend splitting in your chosen programming language. According to guidelines at https://en.wikipedia.org/wiki/Help:URL

Matches protocol, domain, port, path, query and anchor as named capturing groups.

now matches any protocol, as well as username, password, query and fragment. query is not split

Capture URL without Query Parameters /^(+).*/gm

This query extract the entire tacacs legacy configuration by servers and divide its parts on groups

Given a JSON.stringified object that may contain secrets, obfuscate them for logging. It will match parameters with "token," "key," and "secret" in strings and key/value pairs. Specifically looks for object values with : setters``, strings with = setters and Authorization headers. This regex will produce 2 groups for each match. Group 1 will have object key/values and = param value pairs from strings such as query strings. Group 2 will have authorization header keys { secret: "hdsuaskleasdkfjs8e229das-43332", urls: { uri_1: "https://www.api.example.com/api/?count=433&apiKey=DD2EXAMPLE248330EFBB58D6B1431AFB03C8E1D&debug=true", uri_7: "https://www.api.example.com/api/?api_key=7119EXAMPLE25C366F9AB506A1BFD&debug=true" }, secret-pin:123456789, headers: {Authorization: "Bearer dasd/4EXAMPLEuCoAO8UaxuWUGXUtuzRJKdRTvKMVe3dJ9FN1SyF9n=="}, auth_3: {Authorization: "App D4DEXAMPLE0BB1B2F12B5E97405C764CA45F"}, auth_4: {Authorization: "IPSO dasd+F51EXAMPLEB63334AD3520894712D15D8F1105ED3DD"}, auth_5: {Authorization: "Key hJdilwrEXAMPLEzM9616MJsDGBiK4qjeJFYB0zmHPxYNUrn8D54ycAN7gwedqHt0UiCWTb"}, auth_8: {Authorization: "Digest username=EXAMPLE, nonce=h8A4EXAMPLEZW22ygGZozIIGZcb43waVMEM6Gq, response='b4543cd4dEXAMPLE6a923b4ab4fd4583af48f0e'} }, apiKey: null, apiKey3: true, apiKey4: false, apiKey5: 'null', apiKey6: 'true' }

pythonize beautiful query

It's a simple regexp for dns-query.log

Grafana Templating : Friendly Variable Values as Display Names Check below Grafana Documentation for the Use Case : https://grafana.com/docs/grafana/latest/dashboards/variables/add-template-variables/#filter-and-modify-using-named-text-and-value-capture-groups This example demonstrates how to extract VLAN ID from Zabbix item names which are automaticaly generated by Zabbix Discovery Rules. Grafana - Zabbix Integration uses these items to poll for data. Therefore while templating with variables whose values are dynamically populated by Zabbix integration queries, related query should match whole string of the item, however should only accept a part of it as value and also has a friendly-name.

Extracts parts of an URL into regex groups: ((?:(?:http|ftp|ws)s?|sftp):\/\/?)?(group 1): extracts the protocol (+\.+|localhost)(group 2): extracts the hostname (:\d+)?(group 3): extracts the port number ((?:\/\w+)\/)?(\w\-.]++)?(groups 4 & 5)*: extracts the path part (+)?(group 6): extracts the query part (#[\w-])?(group 7)*: extracts the hash part For every part of the regex listed above, you can remove the ending ? to force it (or add one to make it facultative). You can also remove the ^ at the beginning and $ at the end of the regex so it won't need to match the whole string. See on [stackoverflow.com. *Note: this regex is not 100% safe and may accept some strings which are not necessarily valid URLs but it does indeed validate some criterias. Its main goal was to extract the different parts of an URL not to validate it.*

Parse Graphql queries Changelog (versions): Initial Version 2 is much improved and intended to integrate well with customized highlighting with the help of the awesome Rich library. Bug fixes and added rich example. Bugfixes and now the regex is actually recognizing the different parts of field_with_params. And an improved example to go with that. Todo (maybe): Improve the beginning, opening, closing and ending curly bracket recognition with better support for malformed queries and make sure there's only one BEGIN and one END in situations where newlines are present. Also differentiate between arbitrary text and actual graphql query language content. For example, the string "asdf" is currently recognized and categorized as a child_field when it shouldn't be recognized at all. Version 4 def pretty_query(query_string: str) -> str: import re from rich.console import Console from rich.highlighter import JSONHighlighter from rich.theme import Theme, DEFAULT_STYLES this is a string, not a tuple field_with_params_rgx = ( r'(?P+' # fields with parameters r'(?P\()' # opening parenthesis r'(?P\w+)\s?' # keywords and colons r'(?P\:)\s?' # keywords and colons r'(?P' # parameter values r'(?P\[?).+?' # opening square bracket r'(?P\]?))\s?' # closing square bracket r'(?P\)))' # closing parenthesis ) regexes = [ field_with_params_rgx, r'(?P^\{)|(?P\{)|(?P\}$)|(?P\})', # curly brackets r'(?P(?P\.{3})\s*?(?Pon)\s+?(?P\w+))', # fragments r'(?P(?!(?P=field_with_params)|(?P=fragment))\w+)(?=\s*?\{)', # parent fields r'(?P(?!(?P=field_with_params)|(?P=fragment))\w+)', # child fields ] indent = 2 count = 0 parts = [] for x in re.finditer('|'.join(rgx for rgx in regexes), query_string): data = x.groupdict() string = '' BEGIN = data['BEGIN'] open = data['open'] parent_field = data['field_with_params'] or data['parent_field'] child_field = data['child_field'] fragment = data['fragment'] close = data['close'] END = data['END'] if BEGIN: string += BEGIN count += indent if open: count += indent continue if parent_field: string += '{0: >{fill}}{value} {{'.format(' ', value=parent_field, fill=count) if child_field: string += '{0: >{fill}}{value}'.format(' ', value=child_field, fill=count) if fragment: string += '{0: >{fill}}{value} {{'.format(' ', value=fragment, fill=count) if close: count -= indent string += '{0: >{fill}}{value}'.format(' ', value=close, fill=count) if END: string += END count -= indent parts.append(string) class GQLHighlighter(JSONHighlighter): base_style = "gql." highlights = ['|'.join(rgx for rgx in regexes)] + JSONHighlighter.highlights theme = Theme({ **{ f'gql.{k}': DEFAULT_STYLES[f'json.{k}'] for k in ['brace', 'bool_true', 'bool_false', 'null', 'number', 'str', 'key'] }, 'gql.BEGIN': 'bold green', 'gql.END': 'bold green', 'gql.open': 'bold yellow', 'gql.close': 'bold blue', 'gql.field_with_params': 'bold blue', 'gql.parent_field': 'bold white', 'gql.child_field': 'italic green', 'gql.fragment': 'bold yellow', 'gql.dots': 'bold white', 'gql.on': 'green', 'gql.frag_field': 'bold magenta italic', 'gql.parenth_open': 'blue', 'gql.parenth_close': 'green', 'gql.keyword': 'yellow', 'gql.colon': 'blue', 'gql.list_open': 'bold yellow', 'gql.list_close': 'bold yellow', 'gql.value': 'cyan', }) console = Console(highlighter=GQLHighlighter(), theme=theme) console.print('\n'.join(parts)) return '\n'.join(parts)

scheme host port path query

SQL Query Scalar Field Names Extractor

Working on a regex to extract path and query params

asdasd

Grabs another regex from the Public Library to do most of the dirty work. When a tab is opened it scans and the: head header body Determines the type of site it is: Query Doc Assigns weights based on types.

Show queries that define different user intent based on commercial queries.

Show queries that define user intent based on navigation

Show queries that defines user intent for informational queries

This is a regex expression to match URL with 'w' (width) and 'crop' query vars

Looks for "shortcut icon" or "icon" in a link rel and will strip query strings.

query string filters

int&space to 'int',

Select the LIMIT/OFFSET clause of an SQL query

trino kill query ID

trino kill query

SQL comments on Big Query

pdf extension whether query strings or no

any given url inside a text will be recognized and split into different groups: url (full url) scheme hostname (subdomain + domain + tld) port path query (GET-parameters) while the only group required for a match is the hostname, therefore example.com would allready be a match.

Searches for the first list element in a graphql query, which allows for filtering and pagination, except for the group node

A well-documented, easy to modify bulletproof regular expression that matches complete URLs or URL components. Components include: Schema scheme/protocol: use an OR statement to add FTP, etc. hostname: use OR statements to more TLDs port: matches leading zero; to disable, change the first block in the subexpression to [1-9] from [0-9] path query: to capture subcomponents of the query string, delete the target symbol in the `` subexpression fragment ☛ The name of the captured subexpression is usually case-sensitive. Substitution Complete URL ${URL}, \1, or its equivalent, can be used to backreference or substitute the complete URL. \1 $1 ${URL} $+{URL} URL Component Map ${SCHEME} → \2 ${HOSTNAME} → \3 ${PORT} → \4 ${PATH} → \5 ${QUERY} → \6 ${FRAGMENT} → \7 Plug & Play substitution/backreference alternatives \2\3\4\5\6\7 $2$3$4$5$6$7 ${2}${3}${4}${5}${6}${7} ${SCHEME}${HOSTNAME}${PORT}${PATH}${QUERY}${FRAGMENT} $+{SCHEME}$+{HOSTNAME}$+{PORT}$+{PATH}$+{QUERY}$+{FRAGMENT}

Used for a BizTalk Application Event trigger in Zabbix. Should match when both sentences are matched and everything between the sentences can be random