marianogappa / Sqlparser
Licence: mit
Simple SQL parser meant for querying CSV files
Stars: ✭ 249
Programming Languages
go
31211 projects - #10 most used programming language
Projects that are alternatives of or similar to Sqlparser
Tableqa
AI Tool for querying natural language on tabular data.
Stars: ✭ 109 (-56.22%)
Mutual labels: csv, sql
Neo4j Etl
Data import from relational databases to Neo4j.
Stars: ✭ 165 (-33.73%)
Mutual labels: csv, sql
Rbql
🦜RBQL - Rainbow Query Language: SQL-like language for (not only) CSV file processing. Supports SQL queries with Python and JavaScript expressions
Stars: ✭ 118 (-52.61%)
Mutual labels: csv, sql
Pxi
🧚 pxi (pixie) is a small, fast, and magical command-line data processor similar to jq, mlr, and awk.
Stars: ✭ 248 (-0.4%)
Mutual labels: csv, parser
Flora Sql Parser
Parse SQL (select) statements into abstract syntax tree (AST) and convert ASTs back to SQL.
Stars: ✭ 186 (-25.3%)
Mutual labels: sql, parser
Omniparser
omniparser: a native Golang ETL streaming parser and transform library for CSV, JSON, XML, EDI, text, etc.
Stars: ✭ 148 (-40.56%)
Mutual labels: csv, parser
Joiner
A simple utility for SQL-like joins with Json, GeoJson or dbf data in Node, the browser and on the command line. Also creates join reports so you can know how successful a given join was. Try it in the browser -->
Stars: ✭ 47 (-81.12%)
Mutual labels: csv, sql
Bancosbrasileiros
Lista de bancos brasileiros | Brazilian banks list
Stars: ✭ 178 (-28.51%)
Mutual labels: csv, sql
Ts Sql
A SQL database implemented purely in TypeScript type annotations.
Stars: ✭ 2,324 (+833.33%)
Mutual labels: sql, parser
Countries States Cities Database
🌍 World countries, states, regions, provinces, cities, towns in JSON, SQL, XML, PLIST, YAML, and CSV. All Countries, States, Cities with ISO2, ISO3, Country Code, Phone Code, Capital, Native Language, Timezones, Latitude, Longitude, Region, Subregion, Flag Emoji, and Currency. #countries #states #cities
Stars: ✭ 1,130 (+353.82%)
Mutual labels: csv, sql
Octosql
OctoSQL is a query tool that allows you to join, analyse and transform data from multiple databases and file formats using SQL.
Stars: ✭ 2,579 (+935.74%)
Mutual labels: csv, sql
Csv Parser
Fast, header-only, extensively tested, C++11 CSV parser
Stars: ✭ 90 (-63.86%)
Mutual labels: csv, parser
Sqlformat
.NET SQL Parser and Formatter Tool and SSMS Plugin
Stars: ✭ 49 (-80.32%)
Mutual labels: sql, parser
Dumpling
Dumpling is a fast, easy-to-use tool written by Go for dumping data from the database(MySQL, TiDB...) to local/cloud(S3, GCP...) in multifarious formats(SQL, CSV...).
Stars: ✭ 134 (-46.18%)
Mutual labels: csv, sql
Ether sql
A python library to push ethereum blockchain data into an sql database.
Stars: ✭ 41 (-83.53%)
Mutual labels: csv, sql
Node Csv Stringify
CSV stringifier implementing the Node.js `stream.Transform` API
Stars: ✭ 179 (-28.11%)
Mutual labels: csv, parser
Tsql Parser
Library Written in C# For Parsing SQL Server T-SQL Scripts in .Net
Stars: ✭ 203 (-18.47%)
Mutual labels: sql, parser
sqlparser - meant for querying csv files
Usage
package main
import (
"fmt"
"log"
"github.com/marianogappa/sqlparser"
)
func main() {
query, err := sqlparser.Parse("SELECT a, b, c FROM 'd' WHERE e = '1' AND f > '2'")
if err != nil {
log.Fatal(err)
}
fmt.Printf("%+#v", query)
}
Example: SELECT works
query, err := sqlparser.Parse(`SELECT a FROM 'b'`)
query.Query {
Type: Select
TableName: b
Conditions: []
Updates: map[]
Inserts: []
Fields: [a]
}
Example: SELECT works with lowercase
query, err := sqlparser.Parse(`select a fRoM 'b'`)
query.Query {
Type: Select
TableName: b
Conditions: []
Updates: map[]
Inserts: []
Fields: [a]
}
Example: SELECT many fields works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b'`)
query.Query {
Type: Select
TableName: b
Conditions: []
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT with WHERE with = works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a = ''`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Eq,
Operand2: ,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT with WHERE with < works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a < '1'`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Lt,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT with WHERE with <= works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a <= '1'`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Lte,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT with WHERE with > works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a > '1'`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Gt,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT with WHERE with >= works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a >= '1'`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Gte,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT with WHERE with != works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a != '1'`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Ne,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT with WHERE with != works (comparing field against another field)
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a != b`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Ne,
Operand2: b,
Operand2IsField: true,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: SELECT * works
query, err := sqlparser.Parse(`SELECT * FROM 'b'`)
query.Query {
Type: Select
TableName: b
Conditions: []
Updates: map[]
Inserts: []
Fields: [*]
}
Example: SELECT a, * works
query, err := sqlparser.Parse(`SELECT a, * FROM 'b'`)
query.Query {
Type: Select
TableName: b
Conditions: []
Updates: map[]
Inserts: []
Fields: [a *]
}
Example: SELECT with WHERE with two conditions using AND works
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a != '1' AND b = '2'`)
query.Query {
Type: Select
TableName: b
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Ne,
Operand2: 1,
Operand2IsField: false,
}
{
Operand1: b,
Operand1IsField: true,
Operator: Eq,
Operand2: 2,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: [a c d]
}
Example: UPDATE works
query, err := sqlparser.Parse(`UPDATE 'a' SET b = 'hello' WHERE a = '1'`)
query.Query {
Type: Update
TableName: a
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Eq,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[b:hello]
Inserts: []
Fields: []
}
Example: UPDATE works with simple quote inside
query, err := sqlparser.Parse(`UPDATE 'a' SET b = 'hello\'world' WHERE a = '1'`)
query.Query {
Type: Update
TableName: a
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Eq,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[b:hello\'world]
Inserts: []
Fields: []
}
Example: UPDATE with multiple SETs works
query, err := sqlparser.Parse(`UPDATE 'a' SET b = 'hello', c = 'bye' WHERE a = '1'`)
query.Query {
Type: Update
TableName: a
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Eq,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[b:hello c:bye]
Inserts: []
Fields: []
}
Example: UPDATE with multiple SETs and multiple conditions works
query, err := sqlparser.Parse(`UPDATE 'a' SET b = 'hello', c = 'bye' WHERE a = '1' AND b = '789'`)
query.Query {
Type: Update
TableName: a
Conditions: [
{
Operand1: a,
Operand1IsField: true,
Operator: Eq,
Operand2: 1,
Operand2IsField: false,
}
{
Operand1: b,
Operand1IsField: true,
Operator: Eq,
Operand2: 789,
Operand2IsField: false,
}]
Updates: map[b:hello c:bye]
Inserts: []
Fields: []
}
Example: DELETE with WHERE works
query, err := sqlparser.Parse(`DELETE FROM 'a' WHERE b = '1'`)
query.Query {
Type: Delete
TableName: a
Conditions: [
{
Operand1: b,
Operand1IsField: true,
Operator: Eq,
Operand2: 1,
Operand2IsField: false,
}]
Updates: map[]
Inserts: []
Fields: []
}
Example: INSERT works
query, err := sqlparser.Parse(`INSERT INTO 'a' (b) VALUES ('1')`)
query.Query {
Type: Insert
TableName: a
Conditions: []
Updates: map[]
Inserts: [[1]]
Fields: [b]
}
Example: INSERT with multiple fields works
query, err := sqlparser.Parse(`INSERT INTO 'a' (b,c, d) VALUES ('1','2' , '3' )`)
query.Query {
Type: Insert
TableName: a
Conditions: []
Updates: map[]
Inserts: [[1 2 3]]
Fields: [b c d]
}
Example: INSERT with multiple fields and multiple values works
query, err := sqlparser.Parse(`INSERT INTO 'a' (b,c, d) VALUES ('1','2' , '3' ),('4','5' ,'6' )`)
query.Query {
Type: Insert
TableName: a
Conditions: []
Updates: map[]
Inserts: [[1 2 3] [4 5 6]]
Fields: [b c d]
}
Example: empty query fails
query, err := sqlparser.Parse(``)
query type cannot be empty
Example: SELECT without FROM fails
query, err := sqlparser.Parse(`SELECT`)
table name cannot be empty
Example: SELECT without fields fails
query, err := sqlparser.Parse(`SELECT FROM 'a'`)
at SELECT: expected field to SELECT
Example: SELECT with comma and empty field fails
query, err := sqlparser.Parse(`SELECT b, FROM 'a'`)
at SELECT: expected field to SELECT
Example: SELECT with empty WHERE fails
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE`)
at WHERE: empty WHERE clause
Example: SELECT with WHERE with only operand fails
query, err := sqlparser.Parse(`SELECT a, c, d FROM 'b' WHERE a`)
at WHERE: condition without operator
Example: Empty UPDATE fails
query, err := sqlparser.Parse(`UPDATE`)
table name cannot be empty
Example: Incomplete UPDATE with table name fails
query, err := sqlparser.Parse(`UPDATE 'a'`)
at WHERE: WHERE clause is mandatory for UPDATE & DELETE
Example: Incomplete UPDATE with table name and SET fails
query, err := sqlparser.Parse(`UPDATE 'a' SET`)
at WHERE: WHERE clause is mandatory for UPDATE & DELETE
Example: Incomplete UPDATE with table name, SET with a field but no value and WHERE fails
query, err := sqlparser.Parse(`UPDATE 'a' SET b WHERE`)
at UPDATE: expected '='
Example: Incomplete UPDATE with table name, SET with a field and = but no value and WHERE fails
query, err := sqlparser.Parse(`UPDATE 'a' SET b = WHERE`)
at UPDATE: expected quoted value
Example: Incomplete UPDATE due to no WHERE clause fails
query, err := sqlparser.Parse(`UPDATE 'a' SET b = 'hello' WHERE`)
at WHERE: empty WHERE clause
Example: Incomplete UPDATE due incomplete WHERE clause fails
query, err := sqlparser.Parse(`UPDATE 'a' SET b = 'hello' WHERE a`)
at WHERE: condition without operator
Example: Empty DELETE fails
query, err := sqlparser.Parse(`DELETE FROM`)
table name cannot be empty
Example: DELETE without WHERE fails
query, err := sqlparser.Parse(`DELETE FROM 'a'`)
at WHERE: WHERE clause is mandatory for UPDATE & DELETE
Example: DELETE with empty WHERE fails
query, err := sqlparser.Parse(`DELETE FROM 'a' WHERE`)
at WHERE: empty WHERE clause
Example: DELETE with WHERE with field but no operator fails
query, err := sqlparser.Parse(`DELETE FROM 'a' WHERE b`)
at WHERE: condition without operator
Example: Empty INSERT fails
query, err := sqlparser.Parse(`INSERT INTO`)
table name cannot be empty
Example: INSERT with no rows to insert fails
query, err := sqlparser.Parse(`INSERT INTO 'a'`)
at INSERT INTO: need at least one row to insert
Example: INSERT with incomplete value section fails
query, err := sqlparser.Parse(`INSERT INTO 'a' (`)
at INSERT INTO: need at least one row to insert
Example: INSERT with incomplete value section fails #2
query, err := sqlparser.Parse(`INSERT INTO 'a' (b`)
at INSERT INTO: need at least one row to insert
Example: INSERT with incomplete value section fails #3
query, err := sqlparser.Parse(`INSERT INTO 'a' (b)`)
at INSERT INTO: need at least one row to insert
Example: INSERT with incomplete value section fails #4
query, err := sqlparser.Parse(`INSERT INTO 'a' (b) VALUES`)
at INSERT INTO: need at least one row to insert
Example: INSERT with incomplete row fails
query, err := sqlparser.Parse(`INSERT INTO 'a' (b) VALUES (`)
at INSERT INTO: value count doesn't match field count
Example: INSERT * fails
query, err := sqlparser.Parse(`INSERT INTO 'a' (*) VALUES ('1')`)
at INSERT INTO: expected at least one field to insert
Note that the project description data, including the texts, logos, images, and/or trademarks,
for each open source project belongs to its rightful owner.
If you wish to add or remove any projects, please contact us at [email protected].