writing basic Ruby code to register user in SQLite database

There are a few problems with your code. First, here:

db.execute("INSERT INTO users (user, pass)
            VALUES (#{user}, #{pass})")

You're trying to generate a query that looks like this (supposing the variable user contains "Jordan" and pass contains "xyz"):

INSERT INTO users (user, pass) VALUES('Jordan', 'xyz')

...but your code generates a query that looks like this:

INSERT INTO users (user, pass) VALUES(Jordan, xyz)

Do you see the difference? Values in SQL queries need to be surrounded by quotation marks. Your query will fail because SQLite doesn't know what Jordan is; it only knows what 'Jordan' is.

You could just add quotation marks to your query, but then you would have another problem: SQL injection attacks. Because you're just blindly putting the values of user and pass into your query, an attacker could manipulate those values to perform a different query than you intended. Never use string interpolation (#{var}) or concatenation (+ or <<) when creating an SQL query. (For a brief description of how SQL injection attacks work, read the "How to get hacked" section on this page: http://ruby.bastardsbook.com/chapters/sql/.)

The correct way to use variables in a query is with prepared statements and parameter binding. It looks like this:

statement = db.prepare("INSERT INTO users (user, pass) VALUES (?, ?)")
statement.bind_params(user, pass)
result = statement.execute

What this does is automatically escapes the values of user and pass to make sure they don't do anything you don't expect, wraps them in quotation marks, and substitutes them for the question marks in the query. Another way to do the same thing is this:

result = db.execute("INSERT INTO users (user, pass) VALUES (?, ?)", user, pass)

The other obvious problem with your code is this:

if register_user(#{@nick}, l[1])

This is a syntax error. You can only use the #{var} syntax in a string, like "hello #{var}". In this case you just want to do this:

if register_user(@nick, l[1])

require "sqlite3"

my_db = SQLite3::Database.new "my_db1.db"

my_db.execute <<END_OF_CREATE  #The <<END_OF_CREATE .... END_OF_CREATE thing is called HEREDOC syntax, which is one way to create a String that spans multiple lines
  CREATE TABLE IF NOT EXISTS users(    #A useful SQL command to be aware of.
    name varchar(30),
    password  varchar(30)
  );
END_OF_CREATE

def register_user(target_db, user_info)
    user_name, user_pass = user_info  #A neat trick for "unpacking" an Array

    target_db.execute(
      "INSERT INTO users (name, password)
       VALUES (?, ?)", user_name, user_pass   #For security reasons, inserts into a db should use this "question mark" format.
    )
end

register_user(my_db, ['John', 'abc123'])
register_user(my_db, ['Jane', 'xyz456'])

my_db.execute("SELECT * FROM users") do |row|
  p row  #Use the 'p' method instead of puts to print an Array or Hash.
end

--output:--
["John", "abc123"]
["Jane", "xyz456"]

Also, don't ever name a variable l. You absolutely, no exceptions, have to use descriptive variable names. See the code above for an example.

Even though the code above unpacks the user_info array into separate variables, that is actually not required because execute() will take an Array as an argument:

target_db.execute(
  "INSERT INTO users (name, password) 
   VALUES (?, ?)", user_info
)

In other words, all the values for the question marks can be gathered into an Array and provided as the last argument for execute().

One problem you can run into when writing and testing database programs is when you change one of the column names in your table. The code above will cause an error: the table will not be re-created because the table already exists, but your new code will use the new column name, which won't exist in the table.

So, you might consider using this combination of sql statements:

my_db.execute <<END_OF_DROP
  DROP TABLE IF EXISTS users
END_OF_DROP

my_db.execute <<END_OF_CREATE
  CREATE TABLE users(
    name varchar(30),
    password  varchar(30)
  );
END_OF_CREATE

With those sql statements, if you change one of the column names (or add a column), then your new code won't throw an error because the table is destroyed and recreated with the new column names every time you run your program.