
Sourcegraph is actively working to index open source software so that developers can search all of the code that they care about. Being able to search across public repositories can help you learn open source best practices, inspect the libraries you may have as dependencies on your projects, and provide you with real-world examples you can leverage while you’re programming.

This tutorial will guide you through how to add public, open source repositories from GitHub and GitLab to Sourcegraph so that these code bases are indexed by the platform. Once you have added and synched these public repositories, anyone using Sourcegraph Cloud will be able to see results from these projects when they search all the code that is available through Sourcegraph via its global context.

To add public repositories to Sourcegraph, you’ll need a free Sourcegraph account, which you can set up by following our documentation on [getting started with Sourcegraph](https://docs.sourcegraph.com/getting-started#how-do-i-start-using-sourcegraph).

## Step 1 — Access User Settings

Log into [Sourcegraph.com](https://sourcegraph.com) and click on your user icon on the top right corner of the page.

A drop-down menu will be displayed. From here, click on **Settings**.

![Sourcegraph home with user menu](/tutorial-images/sourcegraph-home-user-menu.png)

You’ll be taken to a page that indicates that you are in your settings with a header of **User Settings** displayed towards the top of the page, and a panel with options regarding your user account on the left hand side of the window.

## Step 2 — Add Repositories

From the panel on the left hand side of the interface, you can click on **Repositories** in order to be taken to the page where you can manage repositories. If you already have repositories added, you’ll need to click on the **Manage Repositories** button that is on this page in order to access this page.

![Sourcegraph manage repositories page](/tutorial-images/sourcegraph-manage-repositories.png)

Within the **Manage Repositories** page, you’ll be presented with a few options:

- In the **Your repositories** section, you can sync _your own_ public repositories using GitHub or GitLab.
- In the **Other public repositories** section, you can add any public repositories on GitHub and GitLab.

For now, we’ll focus on the second option, and click the checkbox next to `Sync specific public repositories by URL`. Choosing this option, you can add any public repositories of code from either GitHub or GitLab, whether you contribute to the project or not.

Once you have clicked the checkbox, a check mark sign will appear in the box, like so: &#9745;. At this point, a box will display, similar to the screenshot below.

![Sourcegraph other public repositories list](/tutorial-images/sourcegraph-other-public-repositories.png)

Within the box, you can type URLs of the public open source projects that you care about, one per line, with no separating characters other than the `ENTER` key.

The example above indexed the following two repositories, but you should choose repositories that are important to you, as these are already indexed:

- [github.com/prisma/women-world-wide](https://github.com/prisma/women-world-wide)
- [github.com/do-community/cloud_haiku](https://github.com/do-community/cloud_haiku)

When you are satisfied with the repositories that we have added for now (you can always add more later), you can click the **Save** button below.

## Step 3 — Search the repositories you added

At this point, you’re able to search the public repositories that you added. To verify this, you can scroll up to the top of the page where the Sourcegraph search bar is. To the left of the search bar it states `context:global`, which you can click on to limit it to your own username, to search the repositories you have added.

![Sourcegraph search with global context](/tutorial-images/sourcegraph-context.png)

From here, you can search a common keyword to ensure that the public code you added is available to you.

To ensure that the public code you just added is available to anyone using Sourcegraph (even those not logged in), you can open a new private or incognito window and search for a fairly unique string to the code bases you have just added. In this case, we’ll search for `women world wide` to ensure that the `prisma/women-world-wide` repository is indexed:

<SourcegraphSearch query="women world wide"/>

![Sourcegraph verification of OSS added](/tutorial-images/sourcegraph-anonymous-verification.png)

The screenshot above reveals output from the repository we just added to an anonymous user who is not logged in, which indicates that we have successfully added this public repository to Sourcegraph.

## Next Steps

From here, you may want to sync your GitHub or GitLab account to add your own public repositories or forks.

With open source projects that are important to you fully indexed by Sourcegraph, you will be able to use libraries and other dependencies more effectively, and be able to summon up effective examples quickly while you’re building.


Learn how to add public, open source repositories to Sourcegraph.

How To Add Open Source Software Projects to Sourcegraph


Sourcegraph is a tool that can allow you to search all the code that is important to you, from your own local repositories, to the software you build together with a team, to all the code that is available through open source projects. You can get started using Sourcegraph by using [Sourcegraph Cloud](https://sourcegraph.com/search) with your preferred web browser, or you may want to install Sourcegraph locally or on a cloud server or virtual machine.

By installing Sourcegraph on your own hardware, you’ll be able to manage your own instance of Sourcegraph, providing you with complete control over who has access to your code. Your own installation will also allow you to connect your local (or server-side) code as well as any relevant Git servers. Git servers that you can connect to include GitHub, GitHub Enterprise, GitLab, Bitbucket, AWS CodeCommit, Perforce, and more.

We’ll go through how to install Sourcegraph on your local machine with Docker so that you can begin to use Sourcegraph on all of your code. This installation guide is appropriate for local testing and should be quick to set up. If you would like to use Sourcegraph in a production environment, you should follow our documentation on installing Sourcegraph with [Docker Compose](https://docs.sourcegraph.com/admin/install/docker-compose) on a single node, or on a [Kubernetes cluster](https://docs.sourcegraph.com/admin/install/kubernetes).

## Step 1 — Install Docker

_If you already have Docker installed, you can [skip to the next step](#step-2--install-sourcegraph)._

We’ll go over how to install Docker across [Linux](#on-linux), [macOS](#on-macos), and [Windows](#on-windows) operating systems in this section. Skip down to the section that is relevant for the machine you’re using to install Sourcegraph.

### On Linux

On a Linux cloud server or local computer, you can install Docker via the command line as long as you are a user with super user privileges.

Ensure that you have the [snap package manager](https://snapcraft.io/) installed by running the following commands in your terminal for **Ubuntu or Debian Linux**:

```
sudo apt update
sudo apt install snapd
sudo snap install core
```

If you are using **Fedora**, ensure that snap is installed by running the following command:

```
sudo dnf install snapd
```

If you are using **CentOs**, you can ensure that snap is installed and ready by running the following commands. For more guidance on these commands, please visit snap’s [official documentation](https://snapcraft.io/install/docker/centos).

```
sudo yum install epel-release
sudo yum install snapd
sudo systemctl enable --now snapd.socket
```

Once snap is fully installed, you can install Docker using snap.

```
sudo snap install docker
```

Alternatively, you can install Docker through its `.deb` or `.rpm` packages through the [Docker installation page](https://docs.docker.com/engine/install/).

With Docker installed, you can continue to [Step 2](#step-2--install-sourcegraph).

### On macOS

If you’re on a macOS machine, you can install Docker from the [Docker installation page for Mac](https://docs.docker.com/docker-for-mac/install/). You’ll need to ensure that you are installing the right version for your machine’s respective chip.

You can determine what chip you have by navigating to the Apple menu in the top left corner of your screen, selecting `About This Mac` and reviewing what is displayed next to `Chip` in the window that appears.

Once you know which is the appropriate version to install, select either `Mac with Intel chip` for any macOS machine that is on an Intel chip, or `Mac with Apple chip` for any macOS machine that has an Apple M1 chip. Then follow the guidance from the Docker installation to complete the process.

With Docker fully installed, you’ll be ready to move onto the next section of [installing Sourcegraph](#step-2--install-sourcegraph).

### On Windows

If you’re on a Windows machine, you can install Docker from the [Docker installation page for Windows](https://docs.docker.com/docker-for-windows/install/). Follow the guidance from the Docker installation.

With Docker fully installed, you’ll be ready to move onto the section below to install Sourcegraph. Please note that Sourcegraph can only be tested on Windows 10 as data will not be retained after server restarts, due to a limitation of Docker on Windows.

## Step 2 — Install Sourcegraph

Depending on the machine that you have, you’ll be able to run a Docker command to install Sourcegraph and get up and running with code search on your local repositories and beyond.

We’ll go over four approaches below, the first which is recommended for many local machine use cases, inclusive of [Linux machines and macOS machines with Intel chips](#locally-on-linux-or-on-macos-with-intel-chip). The second option is recommended for [Linux cloud servers](#on-a-linux-server). The third option is for [macOS machines with Apple M1 chips](#on-an-apple-m1-chip-on-macos). Finally, the fourth option is to be able to test Sourcegraph on [Windows machines](#on-windows-1).

### Locally on Linux or on macOs with Intel Chip

On local machines that use a Linux distribution or macOS on an Intel chip, you’ll be able to install Sourcegraph by running the following Docker command.

```
docker run --publish 7080:7080 --publish 127.0.0.1:3370:3370 \
--rm --volume ~/.sourcegraph/config:/etc/sourcegraph \
--volume ~/.sourcegraph/data:/var/opt/sourcegraph \
sourcegraph/server:3.29.0
```

This command is telling your computer to install and run Sourcegraph in port 7080 of your localhost (127.0.0.1) and is calling up the relevant files from the Docker image of Sourcegraph. It is also setting up a store for your Sourcegraph data.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive the output similar to the following:

```
✱ Sourcegraph is ready at: http://127.0.0.1:7080
```

At this point, you’ll be able to move onto the next section to verify your installation.

### On a Linux Server

On a Linux cloud server, you can run the following command to keep your instance of Sourcegraph up and running even after you close your Terminal connection to the server.

```
docker run -d --publish 80:7080 --publish 443:7443 \
--restart unless-stopped \
--volume /root/.sourcegraph/config:/etc/sourcegraph \
--volume /root/.sourcegraph/data:/var/opt/sourcegraph \
sourcegraph/server:3.29.0
```

This command is telling your server to install and run Sourcegraph in port 7080 of your server and is calling up the relevant files from the Docker image of Sourcegraph. It is also setting up a store for your Sourcegraph data.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive output similar to the following. Your server’s IP address will display in place of `your-server-ip-address`.

```
✱ Sourcegraph is ready at: http://your-server-ip-address:7080
```

At this point, you’ll be able to move onto the next section to verify your installation.

### On an Apple M1 chip on macOS

On a macOS machine with an Apple M1 chip, you’ll need to add an extra argument to your Docker command so that the platform does not interfere with the installation and running of Sourcegraph. Run the following command with the `--platform linux/amd64` argument as demonstrated below.

```
docker run \
--publish 7080:7080 --publish 127.0.0.1:3370:3370 \
--platform linux/amd64 \
--rm --volume ~/.sourcegraph/config:/etc/sourcegraph \
--volume ~/.sourcegraph/data:/var/opt/sourcegraph \
sourcegraph/server:3.29.0
```

This command is telling your computer to install and run Sourcegraph in port 7080 of your localhost (127.0.0.1) and is calling up the relevant files from the Docker image of Sourcegraph. It is also setting up a store for your Sourcegraph data.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive output similar to the following:

```
✱ Sourcegraph is ready at: http://127.0.0.1:7080
```

At this point, you’ll be able to move onto the next section to verify your installation.

### On Windows

Due to limitations with Docker for Windows, Sourcegraph can only be tested on Windows as data cannot persist on a Windows installation. Due to that, we’ll remove the `--volume` arguments from the Docker commands above, and run the following command instead.

```
docker run --publish 7080:7080 --publish 127.0.0.1:3370:3370 `
--rm sourcegraph/server:3.29.0
```

_The above command with backtick assumes use of PowerShell. If you're using the Windows Command Prompt, substitute `^` as below._

```
docker run --publish 7080:7080 --publish 127.0.0.1:3370:3370 ^
--rm sourcegraph/server:3.29.0
```

This command is telling your computer to install and run Sourcegraph in port 7080 of your localhost (127.0.0.1) and is calling up the relevant files from the Docker image of Sourcegraph.

Once you run the command, you’ll receive some output indicating that Sourcegraph is getting set up. Sourcegraph will be ready when you receive output similar to the following:

```
✱ Sourcegraph is ready at: http://127.0.0.1:7080
```

At this point, you’ll be able to move onto the next section to verify your installation.

## Step 3 — Verify the Installation

When Sourcegraph is fully installed and ready to be used, the Sourcegraph logo will appear and you should access the URL that is indicated in the Terminal output.

![Installation complete verification on command line](/tutorial-images/sourcegraph-logo-terminal.png)

Open a browser and go to the URL indicated in the output. Keep in mind that if you are using a local machine, you’ll be directed to the localhost, but on a server you should go to the IP address of that server.

The first time you open Sourcegraph, the page that will be displayed will be the page to setup your administrative account.

![Sourcegraph create account and login page](/tutorial-images/sourcegraph-login-page.png)

You can create the account now. This account will be tied to your own instance of Sourcegraph.

Once you set up your account, you’ll be able to add repositories and set up your preferences and configuration.

## Next Steps

Congratulations! You have installed Sourcegraph with Docker and have created an account so that you can begin using Sourcegraph to search all of the code that is important to you.

If you have installed Sourcegraph on a Linux server rather than a local machine, you may want to secure your installation as a next step (to access Sourcegraph via `https` rather than `http`), which you can read more about through our official [Sourcegraph docs](https://docs.sourcegraph.com/admin/http_https_configuration#sourcegraph-single-instance-docker).

Once you have Sourcegraph up and running, and your code repositories available to Sourcegraph, you can check our overview video on the [three ways to search with Sourcegraph](/three-ways-to-search-video) so that you can more effectively search your code.


Learn how to install Sourcegraph on your own machine with Docker

How To Install Sourcegraph with Docker


Sourcegraph code search is a search engine that allows you to search code in your own repositories as well as across public open source code. It supports three kinds of search patterns: literal patterns, regular expression patterns, and structural patterns. In this article, we’ll explore literal search patterns and how to use them.

Performing a literal search is useful when you know the exact string that you’re looking for in a code base, like a particular function or variable name. You can find all occurrences of the name across multiple repositories by using your query as a literal pattern. It’s also useful for finding textual content — like error messages or comments — in the code.

By default, all search queries on Sourcegraph are treated as literal patterns. We’ll discuss a few use cases to find useful results with Sourcegraph.

## Finding function calls and definitions

As a developer, there are many times you may need to learn a new codebase: you may need to understand how best to use a new package, may need to be onboarded into an existing project, or may want to learn best practices from tried and tested software. A productive way to become familiar with a codebase is through selecting a function and understanding how it’s used throughout the code and in what contexts.

For example, if you’re learning how the Linux kernel works, one of the topics that you may want to understand is how Linux uses linked lists. Because linked lists are used throughout the Linux kernel and in driver code, they are a foundational starting point to familiarize yourself with the codebase.

The linked list data structure in Linux is called `list_head`. We can find all instances of the `list_head` structure by searching for it directly:

<SourcegraphSearch query="list_head"/>

As you review the results, you may notice that there are some common functions that are frequently used together with linked lists. One of these functions is `list_add_tail`. To explore further and find all instances of `list_add_tail`, we can start a new search for that specific function:

<SourcegraphSearch query="list_add_tail"/>

Literal search patterns can be used to find more than just functions or variables. They can also be used to find longer pieces of text, like error messages, as we’ll explore in the next section.

## Finding error messages

Literal search can help you find where a particular piece of text occurs within code. For example, if you’re seeing an error message while debugging, it can be helpful to find where that message is defined in the code to get a better idea of what is causing it. You can search for an exact match by copying the error into your search.

Let’s try an example. React is a framework used by many web apps, and its error messages are sometimes hard to debug. When a React component throws an error, it produces an error message like, `React caught an error thrown by Component`. When you get an error message like that, it isn’t always clear what is going on. To learn more about the source of the error, you can search for the error message itself:

<SourcegraphSearch query="React caught an error thrown"/>

By finding where an error message is defined, you can start to understand what conditions will cause this error. In this case, it happens when React catches an error that happened during the rendering phase in one of your components.

This kind of search also gives you an understanding of the inner workings of the codebase, and that can be really helpful to get a better mental model of how it works.

## Finding sequences of words

By default, when searching for literal patterns in Sourcegraph, the entire query will be searched, even if the pattern consists of multiple worlds. You should not put your query in quotes: we’ll go into more detail about this now.

Unlike a web search engine, if you search for two or more words on Sourcegraph, like `const counter`, then you’ll only get results for `const` immediately followed by `counter`, as in the example below.

<SourcegraphSearch query="const counter"/>

Returning to our example in the Linux kernel, we can narrow down our search for `list_head` to only the cases where it’s used as a simple structure ([`struct`][struct]), by searching specifically for the `struct list_head` pattern:

<SourcegraphSearch query="struct list_head"/>

If you want to find all instances of those two words appearing in the same file but not necessarily in sequence, then you can use the `and` operator, or you can switch to regular expression mode.

To use the `and` operator, add it to your search. The following query will find occurrences of `list_head` and `list_add_tail` when they are present anywhere in the same file.

<SourcegraphSearch query="list_head and list_add_tail"/>

If you try one of these examples with quotes around the search query, like `"const counter"`, you’ll notice that you get no results. This is because the quote characters are interpreted literally, so Sourcegraph will search for textual data that includes those quote characters.

There are cases where searching for quote characters is useful. We’ll explore that in the next section.

## Finding quoted string constants

Because quote characters are treated like any other character when you’re in literal pattern mode, you can search for quoted strings by including the quotes in your search.

For example, the quoted string `"ENOENT"` represents the error when a file is not found in Linux, and it’s found in many codebases:

<SourcegraphSearch query='"ENOENT"'/>

By including the quotes in the search query, you can compare this search with the same string, but without quotes. You’ll receive other results, where the string isn’t necessarily in quotes.

<SourcegraphSearch query='ENOENT'/>

## Learn more

We’ve explored how to use Sourcegraph to search for literal patterns like function names, variables names, error messages, and strings. You can learn more about Sourcegraph search syntax in the [documentation].

Literal search patterns are a useful starting point, but often you need to search for patterns in your code that require more flexibility. Sourcegraph offers two other types of patterns: [regular expressions] and [structural search].

To go beyond literal patterns, you can use regular expressions or structural search patterns.

**Related links:**

- [Sourcegraph search query documentation][documentation]
- [Sourcegraph regular expression search][documentation]
- [Sourcegraph structural search][structural search]

[struct]: https://en.wikipedia.org/wiki/Struct_(C_programming_language)
[documentation]: https://docs.sourcegraph.com/code_search/reference/queries
[regular expressions]: https://docs.sourcegraph.com/code_search/reference/queries#regular-expression-search
[structural search]: https://docs.sourcegraph.com/code_search/reference/structural


Learn how to use literal search patterns to search code on Sourcegraph.

How To Search with Sourcegraph using Literal Patterns

Sourcegraph lets you search code across repositories, supporting three kinds of search patterns: literal patterns, regular expression patterns, and structural patterns. In this article, we’ll take a look at regular expressions patterns and how to use them in Sourcegraph.

Regular expressions, often shortened as _regex_, help you find code that matches a pattern (including classes of characters like letters, numbers and whitespace), and can restrict the results to anchors like the start of a line, the end of a line, or word boundary.

## Enabling regular expression search on Sourcegraph

Start searching with regular expression patterns by toggling the dot asterisk (<RegexIcon/> ) button towards the right-hand side of the search box. When you mouse over it you’ll receive a tooltip that reads `Enable regular expression`.

<GifLikeVideo url="/tutorial-images/enable-regex.mp4"/>

Once it is highlighted, you're ready to search with regular expressions.

## Finding a pattern

Regular expressions are useful when you're looking for any strings that match a particular pattern. A common pattern in CSS is the RGB hex color code, like #6495ED (cornflower blue) or #663399 (Rebecca purple).

To match RGB hex color codes, we can write a regular expression that has three parts:

- A hash symbol (`#`)
- A character class for hexadecimal characters: `[0-9a-f]`
- A repetition operator, indicating that we're looking for 6 characters that match the above character class: `{6}`

Combining these parts into one regular expression, we can use this pattern in a Sourcegraph search. To make the results more relevant, we can add the `lang:css` filter so that we target only CSS files.

<SourcegraphSearch query="#[0-9a-f]{6} lang:css" patternType="regexp"/>

Regular expressions are useful for finding patterns like this, where certain classes of characters are repeated a certain number of times.

## Finding a set of function calls

One use case for regular expression search is when you are trying to find examples of file system function calls. You may be interested in functions that read or write files: `readFile` and `writeFile`. While you could search for them individually, it can be useful to perform one search that includes results for both functions.

`readFile` and `writeFile` have a pattern in common: they both end in `File`. We can write a regular expression that expresses this pattern like so:

<SourcegraphSearch query="(read|write)File" patternType="regexp"/>

The above search query uses the regular expression syntax of a pipe (`|`) character, which signifies “or”. We can read the query as a search for “`read` or `write`” followed by `File`.

If you would like to narrow down the scope of the search, you can modify this pattern further. If you would like to specify that you would like to use the file system prefix of `fs`, as in `fs.readFile` or `fs.writeFile`, you can add that prefix to the search. Because the `.` dot character notation has a special regex meaning (it will match all characters), we will want to escape the dot with a backslash (`\`).

<SourcegraphSearch query="fs\.(read|write)File" patternType="regexp"/>

Regular expressions are also useful if you’re looking for a variable that can contain a mix of alphabetic and numeric characters, like `id1`, `id2`, `id3` and so forth. To narrow down the results, we can add the `type:symbol` filter.

<SourcegraphSearch query="id\d+ type:symbol" patternType="regexp"/>

In this case `\d+` matches one or more digits.

## Using spaces in regular expression patterns

It’s common to be looking for a pattern with two keywords, separated by any other text in between.

When using regular expressions in Sourcegraph, the space character matches any characters between keywords. So if you search for two words in regular expressions mode, like `auth service`, you’ll get results where `auth` and `service` are found on the same line, and any other number of characters (not limited to spaces) may be in between.

<SourcegraphSearch query="auth service" patternType="regexp"/>

When you use spaces in regular expressions in Sourcegraph, the space character is automatically interpreted as replaced by the `.*` pattern. This pattern matches any number of characters on the same line (including none). When you’re looking for two words appearing together in a code base, but not necessarily right next to each other, regular expression mode is a useful way to find relevant results.

## Finding whole words using word boundaries

By default, Sourcegraph finds all occurrences of your search pattern even when it occurs inside of a longer word. Sometimes when you’re searching for a pattern like `count`, you’re only interested in functions or variables called `count` and not `counter` or `countId` or `countItems`. In those cases, you should specify that you’re looking for an exact keyword. You can do this with the regular expression `\b`, which stands for _word boundary_.

<SourcegraphSearch query="\bcount\b" patternType="regexp"/>

We can use this to improve the search from our earlier example. You may have noticed that the search for `readFile` and `writeFile` returned other functions that started with those patterns, like `readFileAsync`. By using a word boundary, we can restrict the search to only match the exact function name.

<SourcegraphSearch query="(read|write)File\b" patternType="regexp"/>

In the above search we’re adding `\b` at the end of the query, but not at the beginning. This way, we can express that we’re looking for matches that end with this pattern, but may have an alternate prefix.

## Finding patterns at the start of a line

We’ve looked at ways to find matches that are located anywhere in a given line of code. What if you want to narrow down your search to find only the instances when the word is located at the start of the line?

You can use the line start character, `^`, and the line end character, `$`, to anchor your search. For example, here is a search that matches the word `let` when it occurs at the start of the line.

<SourcegraphSearch query="^let" patternType="regexp"/>

This won’t match lines where there’s anything before `let` on the line. That means if there’s whitespace at the beginning of the line, like tabs or spaces for indentation, then that line won’t be considered matches. Since indentation is common in code, you may want to modify the search to include results where `let` can be optionally preceded by any amount of whitespace.

This is where the `\s*` pattern is useful; it matches any number of whitespace characters (zero or more). By adding it in front of `let`, you can now include all results where the line has indentation whitespace.

<SourcegraphSearch query="^\s*let" patternType="regexp"/>

## Learn more

Regular expressions are a powerful syntax for searching code, and in this tutorial we’ve only covered some fundamental features. Sourcegraph uses the RE2 style of regular expressions, which you can learn more about by reading the [RE2 documentation](https://github.com/google/re2/wiki/Syntax).

Using RegEx with Sourcegraph

Learn how to use regular expression search patterns to search code on Sourcegraph.

How To Search with Sourcegraph using Regular Expression Patterns


<EmbeddedYoutubeVideo id="XLfE2YuRwvw" />

In this video:

- Literal search ([tutorial](/literal-search-patterns), [docs](https://docs.sourcegraph.com/code_search/reference/queries#literal-search-default))
- Regular expression search ([tutorial](/regular-expression-patterns), ([docs](https://docs.sourcegraph.com/code_search/reference/queries#regular-expression-search))
- Structural search ([docs](https://docs.sourcegraph.com/code_search/reference/structural))

## Transcript

Hi, my name is Marek. And I'm going to tell you about the different ways that you can search with Sourcegraph. So, Sourcegraph supports three different search modes: literal search, regular expressions, and structural search. I'll tell you a little bit about each one and how you can use them.

By default Sourcegraph searches in literal search mode. This is useful when you're looking to find an exact match. For example, if you're looking for a function name, or a variable name, or an exact string in your code. Let's say that I'm looking for a function called "ReadFile". I can search for directly, and it'll find exact matches. But I can also narrow this down by saying I'm only looking for results in the Go language. So I'm getting results from a variety of different repositories that match the exact query "ReadFile".

Sometimes you're not looking for an exact match, but you're looking for a pattern. Regular Expression search can help you find patterns in you in your code. Suppose I'm looking for CSS colors that are defined as six character hex codes. I know that the CSS color code format can be defined as a regular expression. And it starts with a hash symbol, followed by characters in the range between zero and nine and between A and F. And that's repeated six times. So I've just written that pattern as a regular expression. And I can also add the keyword that narrows this down to only CSS files. And I'll enable regular expression mode for this one. So now I'm getting results that are matching anything that looks like a hex color code. I could expand on this query by adding that I'm only looking for cases where background color is the property that's been set. So now with this search query, I will see only results that match background color, followed by a hex code.

Regular expressions are useful when you're looking for a pattern in your code. But sometimes you want to take into account the actual structure of your code. This is where structural search can help. Let me show you an example. I'll enable structural search. And let's say for example, I'm looking for a function call to a function called "WriteFile". And I know that the instance that I'm looking for is where the first argument is called "path". But I wanted that to match any other arguments after that. So I'm going to use the three dots that match any other arguments in a structural search. I'm also going to restrict this only to Go files. So now I'm getting matches that correspond to function calls where the first argument is path. But the other arguments could be anything. Notice that this is using matching brackets. So even if there are expressions in this function call that contain other brackets, the search will still take that into account and correctly match the entire function call.

Now, in some cases, I see that the constant that's used as the last argument here is relevant. So I may want to narrow the search down and actually search for only the calls where a particular constant is being used as the final argument here. So if I redo this search, the now I'm seeing that I'm getting results for this function call where the first argument is the one I've specified, as well as the last one, but I'm matching any arguments in between, and they can be any expressions in the code.

So I've given you an overview of the three different ways that you can search with Sourcegraph. With each of these modes, you can also filter down by a variety of criteria like programming language, repositories, and file names and a lot of other things too. So you can look at our search query docs to learn more.


How To Add Open Source Software Projects to Sourcegraph

How To Install Sourcegraph with Docker

How To Search with Sourcegraph using Literal Patterns

How To Search with Sourcegraph using Regular Expression Patterns

Three Ways to Search with Sourcegraph (Video)