<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Aaron Mendelson on Medium]]></title>
        <description><![CDATA[Stories by Aaron Mendelson on Medium]]></description>
        <link>https://medium.com/@aaron.mendelsa?source=rss-6eac4ef8d357------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*oBhjMPZCrZxW85Sx.jpg</url>
            <title>Stories by Aaron Mendelson on Medium</title>
            <link>https://medium.com/@aaron.mendelsa?source=rss-6eac4ef8d357------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 00:24:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aaron.mendelsa/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Fuzzy Matching in Snowflake: A Non-Exhaustive Guide]]></title>
            <link>https://medium.com/snowflake/fuzzy-matching-in-snowflake-a-non-exhaustive-guide-b4487174269a?source=rss-6eac4ef8d357------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4487174269a</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[snowflake]]></category>
            <category><![CDATA[snowflake-cortex]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[fuzzy-matching]]></category>
            <dc:creator><![CDATA[Aaron Mendelson]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 19:01:01 GMT</pubDate>
            <atom:updated>2026-07-10T19:01:01.383Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>If you’ve ever wrangled data, you know how painful it can be to match messy records with typos and non-standard spellings to a canonical set of “golden names.” Typically, it’s a labor-intensive process requiring multiple platforms and methods.</p><p>In the following article, I will show how you can build a complete fuzzy matching pipeline inside Snowflake that prioritizes speed and cost without sacrificing accuracy. We will build a 4-stage fuzzy matching pipeline: string matching using regular expressions, hybrid search with Cortex Search, algorithmic matching using Jaro-Winkler, and finally an LLM invocation using the Snowflake AI_COMPLETE function.</p><p>This article uses synthetic transactions with non-standard credit card names. See <a href="https://github.com/Aaron-W-Mendelson/fuzzy-matching/tree/main">this</a> repo for setup scripts if you’d like to follow along.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*_pg--F-qpNdlnXA78uIglg.png" /></figure><h3>Overview of Available Methods</h3><p>This table is a non-exhaustive list of Snowflake-native functions and features you can use for fuzzy matching.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o36oH-aGqHaRhG6FcrhVzQ.png" /></figure><h4><strong>String Manipulations</strong></h4><p>Regular expressions are SQL-native tools for pattern matching and string manipulation. They have a famously challenging syntax, but are useful for basic data cleaning, especially when there are known patterns to match on. For example, using REGEXP_REPLACE, we can search for any instances of “AMEX “and replace them with “American Express”. By using regular expressions with TRIM and UPPER, we can normalize the strings to facilitate exact string matching.</p><h4><strong>Character-level algorithms</strong></h4><p>Snowflake makes both Jaro-Winkler and Levenshtein algorithms available to run on standard warehouse compute. Both algorithms are excellent for fuzzy matching use cases with small typos or inconsistent spellings.</p><p><strong>Levenshtein</strong> assesses the “edit distance” between two strings as measured by the number of single-character edits (deletions, insertions, substitutions) needed to turn one string into the other.</p><p><strong>Jaro-Winkler</strong> (JW) measures edit distance with a bias for strings with similar beginnings. This was empirically derived based on Winkler’s work matching names for the US Census Bureau — he noticed that typos are more common at the end of names and that most phonetic errors still preserve the initial sound. It also works well for short strings where there isn’t enough semantic meaning for vectors to capture.</p><p>Python libraries like RapidFuzz use these algorithms too, but with Snowflake you can harness the massive parallelism inherent in Snowflake’s compute engine for much better performance.</p><h4><strong>Vector-based Methods</strong></h4><p>Snowflake also has a number of vector-based methods that can help with fuzzy matching. The basic idea is that you can turn a string into a vector. Similar words, phrases, and concepts all have similar vectors regardless of how similar the strings are. For example, vectors for “heart attack” and “myocardial infarction” are similar even though their strings have nothing in common. Similarly, if we were matching two credit cards, these methods might do better than JW and Levenshtein in understanding that “BofA Gold” is the same as “Bank of America Gold Card.”</p><p>But these methods can struggle with short strings where there isn’t enough context for a meaningful vector. They also have trouble handling strings with typos and abbreviations.</p><h4><strong>Cortex Search Batch Inference</strong></h4><p>Snowflake also has a search service for hybrid semantic and keyword search called Cortex Search Batch Inference. Like other semantic-based methods, it uses vectors to capture meaning. But it also has a lexical search method similar to BM25. These two methods work in tandem so that Cortex Search does well with semantic meaning (like vector-based solutions), and cases where words are reordered, or there are missing or added words. Importantly, Cortex Search scales much better than JW because it doesn’t require an expensive cross join that can be infeasible with very large datasets. However, the lexical portion of Cortex Search can still struggle with typos and short strings.</p><h4><strong>LLMs</strong></h4><p>Snowflake hosts leading LLMs within its own security perimeter. These models allow you to bring human-like intelligence and reasoning to evaluate fuzzy matches. Because they’re integrated into the platform via AI_COMPLETE, you can call them as simple SQL functions. Though highly discerning, they are also the most expensive technique, and most customers will want to use them only on the hardest cases.</p><h3>Building the Pipeline</h3><p>As mentioned above, the data used in this article is synthetic data representing dirty credit card names. The goal is to match each “dirty” name to one of 100 canonical “golden” names. We’ll build a 4-stage pipeline tuned for speed, accuracy, and cost-effectiveness.</p><p>Any fuzzy matching pipeline will begin with string matching. Many names will be similar except for capitalization or spacing. We can easily and cheaply match these since they run on traditional Snowflake warehouses that are charged on a per-second basis.</p><p>Then we’ll use Cortex Search. This is a good second step because it scales much better than JW, so we can filter out more records and send a smaller number to that stage. We’ll set the precision threshold relatively high to catch matches with high semantic similarity.</p><p>In the third step, we’ll use JW. This algorithm is very well suited to our dataset, which has credit card names laden with typos and abbreviations (areas where search struggles). Note that most applications of this algorithm require a CROSS JOIN where all records in a dataset are compared to each other, and only the records with the best JW match score are retained. That can get slow and expensive when your datasets are very large. An added benefit of running JW after Cortex Search is that Cortex Search can return the top 5 matches for a specific dirty record, greatly reducing the number of comparisons to run through JW. Like exact string matching, JW runs on traditional Snowflake compute.</p><p>Finally, we’ll use AI_COMPLETE with a Claude model to bring human-level discernment to the problem. It is billed per token and is comparatively more expensive than the other methods.</p><p>First, I will assume that if you want to follow along, you’ve completed <a href="https://github.com/Aaron-W-Mendelson/fuzzy-matching/tree/main">setup.sql</a>. That script creates the database, warehouse, and synthetic dataset you’ll need for the rest of the demo.</p><h3>Funnel Stage 1: Normalization With String Manipulation</h3><p>This is the easiest and cheapest step. It scales well and will reduce the number of records you’ll have to send to more expensive methods. This code takes both dirty credit card names and golden records and strips out whitespace, standardizes case, strips out filler words like “credit,” and then expands obvious abbreviations (e.g., it turns AMEX into American Express).</p><pre>CREATE OR REPLACE TABLE stage1_string_match AS<br>WITH<br>normalized_payments AS (<br>    SELECT<br>        payment_id,<br>        card_name,<br>        TRIM(REGEXP_REPLACE(<br>            REGEXP_REPLACE(<br>                REGEXP_REPLACE(<br>                    REGEXP_REPLACE(<br>                        REGEXP_REPLACE(<br>                            REGEXP_REPLACE(<br>                                REGEXP_REPLACE(<br>                                    REGEXP_REPLACE(<br>                                        REGEXP_REPLACE(<br>                                            UPPER(TRIM(card_name)),<br>                                            &#39;\\s+&#39;, &#39; &#39;<br>                                        ),<br>                                        &#39;(^|\\s)AMEX($|\\s)&#39;, &#39; AMERICAN EXPRESS &#39;<br>                                    ),<br>                                    &#39;(^|\\s)MC($|\\s)&#39;, &#39; MASTERCARD &#39;<br>                                ),<br>                                &#39;(^|\\s)DISC($|\\s)&#39;, &#39; DISCOVER &#39;<br>                            ),<br>                            &#39;\\s+CREDIT\\s+CARD\\s*$&#39;, &#39;&#39;<br>                        ),<br>                        &#39;\\s+CREDIT\\s*$&#39;, &#39;&#39;<br>                    ),<br>                    &#39;\\s+CARD\\s*$&#39;, &#39;&#39;<br>                ),<br>                &#39;[.,\\-]&#39;, &#39; &#39;<br>            ),<br>            &#39;\\s+&#39;, &#39; &#39;<br>        )) AS norm_name<br>    FROM raw_payments<br>),<br>normalized_golden AS (<br>    SELECT<br>        card_id,<br>        canonical_card_name,<br>        TRIM(REGEXP_REPLACE(<br>            REGEXP_REPLACE(<br>                REGEXP_REPLACE(<br>                    REGEXP_REPLACE(<br>                        REGEXP_REPLACE(<br>                            REGEXP_REPLACE(<br>                                REGEXP_REPLACE(<br>                                    REGEXP_REPLACE(<br>                                        REGEXP_REPLACE(<br>                                            UPPER(TRIM(canonical_card_name)),<br>                                            &#39;\\s+&#39;, &#39; &#39;<br>                                        ),<br>                                        &#39;(^|\\s)AMEX($|\\s)&#39;, &#39; AMERICAN EXPRESS &#39;<br>                                    ),<br>                                    &#39;(^|\\s)MC($|\\s)&#39;, &#39; MASTERCARD &#39;<br>                                ),<br>                                &#39;(^|\\s)DISC($|\\s)&#39;, &#39; DISCOVER &#39;<br>                            ),<br>                            &#39;\\s+CREDIT\\s+CARD\\s*$&#39;, &#39;&#39;<br>                        ),<br>                        &#39;\\s+CREDIT\\s*$&#39;, &#39;&#39;<br>                    ),<br>                    &#39;\\s+CARD\\s*$&#39;, &#39;&#39;<br>                ),<br>                &#39;[.,\\-]&#39;, &#39; &#39;<br>            ),<br>            &#39;\\s+&#39;, &#39; &#39;<br>        )) AS norm_name<br>    FROM golden_cards<br>)<br>SELECT<br>    p.payment_id,<br>    p.card_name,<br>    g.canonical_card_name AS matched_golden_name,<br>    g.card_id,<br>    1.0 AS match_score,<br>    &#39;EXACT_NORMALIZED&#39; AS match_method<br>FROM normalized_payments p<br>JOIN normalized_golden g ON p.norm_name = g.norm_name;</pre><p>Now that you’ve run that code, you’ll want to see how many matches you actually produced.</p><pre>SELECT<br>    (SELECT COUNT(*) FROM raw_payments)              AS total_payments,<br>    (SELECT COUNT(*) FROM stage1_string_match)       AS stage1_matched,<br>    ROUND(stage1_matched / total_payments * 100, 1)  AS stage1_pct;</pre><p>Then, we’ll create a new table of all records that were unmatched after stage 1.</p><pre>CREATE OR REPLACE TABLE unmatched_after_stage1 AS<br>SELECT payment_id, card_name<br>FROM raw_payments<br>WHERE payment_id NOT IN (SELECT payment_id FROM stage1_string_match);</pre><h3>Stage 2: Batch Cortex Search</h3><p>For the next stage in the pipeline, we’ll use a Cortex Search service. When you create a search service, you specify a target column. The service then vectorizes that column and builds a keyword search index on it. One of the benefits of using Cortex Search is that it lets you find fuzzy matches without doing an expensive cross join where each item in a list of dirty names is compared to every possible canonical name.</p><p>Here’s how you create a search service.</p><pre>CREATE OR REPLACE CORTEX SEARCH SERVICE golden_card_search<br>    ON canonical_card_name<br>    ATTRIBUTES card_id, card_network, card_tier<br>    WAREHOUSE = FUZZY_MATCHING_WH<br>    TARGET_LAG = &#39;1 hour&#39;<br>    AS (<br>        SELECT<br>            canonical_card_name,<br>            card_id,<br>            card_network,<br>            card_tier<br>        FROM golden_cards);</pre><p>Once you create the search service, give it a few minutes to warm up before continuing. The service will need some time to build the index of golden records. Then we’ll create a “candidates table” consisting of the top 5 canonical matches for each dirty credit card name.</p><pre>CREATE OR REPLACE TABLE stage2_candidates AS<br>SELECT<br>    q.payment_id,<br>    q.card_name,<br>    r.canonical_card_name,<br>    r.card_id,<br>    r.card_network,<br>    r.card_tier,<br>    PARSE_JSON(r.METADATA$RESULT_DETAIL):scores:cosine_similarity::FLOAT AS cosine_score,<br>    ROW_NUMBER() OVER (PARTITION BY q.payment_id ORDER BY cosine_score DESC) AS candidate_rank<br>FROM unmatched_after_stage1 q,<br>    LATERAL CORTEX_SEARCH_BATCH(<br>        service_name =&gt; &#39;FUZZY_MATCHING_DEMO.PUBLIC.GOLDEN_CARD_SEARCH&#39;,<br>        query        =&gt; q.card_name,<br>        limit        =&gt; 5<br>    ) AS r;</pre><p>Next, we’ll filter for the top candidates that also have a cosine score of at least 0.6. This is important because we are setting a relatively high threshold for semantic similarity. That way, we can match records where we have a high confidence in semantic similarity and pass along the rest of the records to parts of the funnel that can handle them better.</p><pre>CREATE OR REPLACE TABLE stage2_cortex_search AS<br>SELECT<br>    payment_id,<br>    card_name,<br>    canonical_card_name AS matched_golden_name,<br>    card_id,<br>    cosine_score        AS match_score,<br>    &#39;CORTEX_SEARCH&#39;     AS match_method<br>FROM stage2_candidates<br>WHERE candidate_rank = 1<br>  AND cosine_score &gt;= 0.60;</pre><p>And lastly, let’s understand how many more records we matched at this stage.</p><pre>SELECT<br>    (SELECT COUNT(*) FROM unmatched_after_stage1)    AS stage2_input,<br>    (SELECT COUNT(*) FROM stage2_cortex_search)      AS stage2_matched,<br>    ROUND(stage2_matched / NULLIF(stage2_input, 0) * 100, 1) AS stage2_pct;</pre><h3>Stage 3: Jaro-Winkler</h3><p>Now that we’ve reduced the number of records we need to match, we can move on to Jaro-Winkler. As discussed above, this algorithm is well-suited to the specific fuzzy matching scenario where we are matching short names with lots of typos and abbreviations. One thing to note is that the method typically uses a CROSS JOIN: every remaining dirty record is joined with every golden record, and only matches with a high enough score are kept. Since we already got the top 5 matches for each record via Cortex Search, we’ll avoid the CROSS JOIN and just use JW on those 5 records.</p><p>First, we’ll create a new candidate table that consists of all records not matched by Cortex Search. For each dirty card name, we’ll calculate the JW similarity score for the top 5 candidates.</p><pre>CREATE OR REPLACE TABLE stage3_jw_scored AS<br>SELECT<br>    c.payment_id,<br>    c.card_name,<br>    c.canonical_card_name,<br>    c.card_id,<br>    c.card_network,<br>    c.card_tier,<br>    c.cosine_score,<br>    JAROWINKLER_SIMILARITY(c.card_name, c.canonical_card_name) / 100.0 AS jw_score,<br>    ROW_NUMBER() OVER (PARTITION BY c.payment_id ORDER BY jw_score DESC) AS jw_rank<br>FROM stage2_candidates c<br>WHERE c.payment_id NOT IN (SELECT payment_id FROM stage2_cortex_search);</pre><p>Then we’ll filter for records that had JW scores above 0.75.</p><pre>CREATE OR REPLACE TABLE stage3_jaro_winkler AS<br>SELECT<br>    payment_id,<br>    card_name,<br>    canonical_card_name AS matched_golden_name,<br>    card_id,<br>    jw_score            AS match_score,<br>    &#39;JARO_WINKLER&#39;      AS match_method<br>FROM stage3_jw_scored<br>WHERE jw_rank = 1<br>  AND jw_score &gt;= 0.75;</pre><p>Lets see how many we matched in this round:</p><pre>SELECT<br>    (SELECT COUNT(*) FROM unmatched_after_stage1) - (SELECT COUNT(*) FROM stage2_cortex_search) AS stage3_input,<br>    (SELECT COUNT(*) FROM stage3_jaro_winkler)    AS stage3_matched,<br>    ROUND(stage3_matched / NULLIF(stage3_input, 0) * 100, 1) AS stage3_pct;</pre><h3>Stage 4: AI_COMPLETE</h3><p>For the final stage of our funnel, we will run the remaining unmatched credit card names through an LLM via the Cortex AI SQL function AI_COMPLETE. Because Snowflake hosts leading LLMs within its security boundaries, when you call AI_COMPLETE not only does the data never leave Snowflake, but you can also use the best model for the job at hand.</p><p>As before, we’ll create a candidate table for this stage:</p><pre>CREATE OR REPLACE TABLE stage4_candidates AS<br>SELECT<br>    c.payment_id,<br>    c.card_name,<br>    c.canonical_card_name,<br>    c.card_id,<br>    c.card_network,<br>    c.card_tier,<br>    c.cosine_score,<br>    JAROWINKLER_SIMILARITY(c.card_name, c.canonical_card_name) / 100.0 AS jw_score<br>FROM stage2_candidates c<br>WHERE c.payment_id NOT IN (SELECT payment_id FROM stage2_cortex_search)<br>  AND c.payment_id NOT IN (SELECT payment_id FROM stage3_jaro_winkler);</pre><p>Then we’ll create a prompt and pass it to AI_COMPLETE and write the results to a table. We’ll also ask the LLM to assign a confidence score to each record it matches.</p><pre>CREATE OR REPLACE TABLE stage4_ai_complete AS<br>WITH candidate_lists AS (<br>    SELECT<br>        payment_id,<br>        card_name,<br>        LISTAGG(<br>            &#39;  - &quot;&#39; || canonical_card_name || &#39;&quot; (id=&#39; || card_id || &#39;, network=&#39; || card_network || &#39;, tier=&#39; || card_tier || &#39;, cosine=&#39; || ROUND(cosine_score, 3) || &#39;, jw=&#39; || ROUND(jw_score, 3) || &#39;)&#39;,<br>            &#39;\n&#39;<br>        ) WITHIN GROUP (ORDER BY cosine_score DESC) AS candidates_text<br>    FROM stage4_candidates<br>    GROUP BY payment_id, card_name<br>),<br>prompts AS (<br>    SELECT<br>        payment_id,<br>        card_name,<br>        &#39;You are a credit card product matching expert. Determine whether the card name from a payment record matches one of the candidate golden card products, or if it is genuinely unknown/unidentifiable.\n\n&#39;<br>        || &#39;Card name from payment record:\n  &quot;&#39; || card_name || &#39;&quot;\n\n&#39;<br>        || &#39;Top candidate golden card products (ranked by search relevance):\n&#39;<br>        || candidates_text || &#39;\n\n&#39;<br>        || &#39;Rules:\n&#39;<br>        || &#39;- Common abbreviations: CSP=Chase Sapphire Preferred, CSR=Chase Sapphire Reserve, CFU=Chase Freedom Unlimited, CFF=Chase Freedom Flex, BCE=Blue Cash Everyday, BCP=Blue Cash Preferred, VX=Venture X, QS=Quicksilver.\n&#39;<br>        || &#39;- If the card name clearly refers to a candidate (accounting for typos, abbreviations, informal names, slang like &quot;Black Card&quot;=Centurion, wrong network attribution), set is_unknown=false and return the matched canonical name exactly as shown.\n&#39;<br>        || &#39;- If none of the candidates are a plausible match (e.g., &quot;Store Credit Card&quot;, &quot;PayPal Credit&quot;, &quot;Affirm&quot;), set is_unknown=true and set matched_name to your best guess at what the card might be.\n&#39;<br>        || &#39;- Set confidence between 0.0 and 1.0.\n&#39;<br>        || &#39;- Respond with JSON only: {&quot;matched_name&quot;:&quot;...&quot;,&quot;confidence&quot;:0.9,&quot;is_unknown&quot;:false,&quot;reasoning&quot;:&quot;...&quot;}&#39;<br>        AS prompt<br>    FROM candidate_lists<br>),<br>llm_results AS (<br>    SELECT<br>        payment_id,<br>        card_name,<br>        TRY_PARSE_JSON(AI_COMPLETE(&#39;claude-sonnet-4-6&#39;, prompt)) AS result<br>    FROM prompts<br>)<br>SELECT<br>    payment_id,<br>    card_name,<br>    result:matched_name::VARCHAR    AS matched_golden_name,<br>    result:confidence::FLOAT        AS confidence,<br>    result:is_unknown::BOOLEAN      AS is_unknown,<br>    result:reasoning::VARCHAR       AS reasoning,<br>    g.card_id,<br>    &#39;AI_COMPLETE&#39; AS match_method<br>FROM llm_results lr<br>LEFT JOIN golden_cards g<br>    ON g.canonical_card_name = lr.result:matched_name::VARCHAR<br>WHERE result IS NOT NULL;</pre><p>Finally, we’ll assign all of the low-confidence matches to a review queue:</p><pre>CREATE OR REPLACE VIEW review_queue AS<br>SELECT<br>    payment_id,<br>    card_name,<br>    matched_golden_name  AS llm_best_guess,<br>    confidence,<br>    is_unknown,<br>    reasoning,<br>    CASE<br>        WHEN is_unknown               THEN &#39;UNKNOWN CARD — confirm identity&#39;<br>        WHEN confidence &lt; 0.7         THEN &#39;LOW CONFIDENCE — verify match manually&#39;<br>        ELSE &#39;UNEXPECTED&#39;<br>    END AS review_reason<br>FROM stage4_ai_complete<br>WHERE is_unknown = TRUE<br>   OR confidence &lt; 0.7;</pre><p>Then we’ll pull all of the matches together into one table:</p><pre>CREATE OR REPLACE TABLE final_matched_payments AS<br><br>-- Stage 1: Normalized exact matches (score = 1.0)<br>SELECT payment_id, card_name, matched_golden_name, card_id, match_score::FLOAT AS match_score, match_method<br>FROM stage1_string_match<br><br>UNION ALL<br><br>-- Stage 2: Cortex Search matches (cosine &gt;= 0.60)<br>SELECT payment_id, card_name, matched_golden_name, card_id, match_score, match_method<br>FROM stage2_cortex_search<br><br>UNION ALL<br><br>-- Stage 3: Jaro-Winkler matches (JW &gt;= 0.75)<br>SELECT payment_id, card_name, matched_golden_name, card_id, match_score, match_method<br>FROM stage3_jaro_winkler<br><br>UNION ALL<br><br>-- Stage 4: AI_COMPLETE confident matches (not unknown, confidence &gt;= 0.7)<br>SELECT payment_id, card_name, matched_golden_name, card_id, confidence AS match_score, match_method<br>FROM stage4_ai_complete<br>WHERE is_unknown = FALSE<br>  AND confidence &gt;= 0.7;</pre><h3>Conclusion</h3><p>In this article, I walked through how to build a complete fuzzy matching pipeline entirely within Snowflake. Through building a funnel that uses string matching, Cortex Search, Jaro-Winkler, and AI_COMPLETE, we matched the vast majority of dirty credit card names to their canonical counterparts.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4487174269a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/snowflake/fuzzy-matching-in-snowflake-a-non-exhaustive-guide-b4487174269a">Fuzzy Matching in Snowflake: A Non-Exhaustive Guide</a> was originally published in <a href="https://medium.com/snowflake">Snowflake Builders Blog: Data Engineers, App Developers, AI, &amp; Data Science</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>